diff --git a/.archive/Archived/CacheCapability.php b/.archive/Archived/CacheCapability.php
new file mode 100644
index 00000000..49e0baa1
--- /dev/null
+++ b/.archive/Archived/CacheCapability.php
@@ -0,0 +1,69 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Archive\Archived;
+
+
+final readonly class CacheCapability
+{
+    public function __construct(
+        public bool $canBeCachedFully,
+        public bool $canBeCachedPartially,
+        public bool $supportsFragments,
+        public CacheComplexity $complexity,
+        public array $restrictions = [],
+    ) {}
+
+    public static function fromTemplateContent(TemplateContent $content): self
+    {
+        $canBeCachedFully = !$content->hasDynamicContent();
+
+        $canBeCachedPartially = !$content->hasUserSpecificContent
+            && !$content->hasSessionData
+            && !$content->hasTimeBasedContent;
+
+        $supportsFragments = count($content->staticBlocks) > 0;
+
+        $complexity = match (true) {
+            !$content->hasDynamicContent() => CacheComplexity::LOW,
+            $content->hasUserSpecificContent || $content->hasSessionData => CacheComplexity::HIGH,
+            $content->hasFormElements || $content->hasTimeBasedContent => CacheComplexity::MEDIUM,
+            default => CacheComplexity::EXTREME,
+        };
+
+        $restrictions = [];
+        if ($content->hasUserSpecificContent) $restrictions[] = 'user_specific';
+        if ($content->hasSessionData) $restrictions[] = 'session_dependent';
+        if ($content->hasTimeBasedContent) $restrictions[] = 'time_sensitive';
+        if ($content->hasCsrfTokens) $restrictions[] = 'csrf_protected';
+
+        return new self(
+            canBeCachedFully: $canBeCachedFully,
+            canBeCachedPartially: $canBeCachedPartially,
+            supportsFragments: $supportsFragments,
+            complexity: $complexity,
+            restrictions: $restrictions,
+        );
+    }
+
+    public function isFullyCacheable(): bool
+    {
+        return $this->canBeCachedFully;
+    }
+
+    public function isPartiallyCacheable(): bool
+    {
+        return $this->canBeCachedPartially;
+    }
+
+    public function getComplexity(): CacheComplexity
+    {
+        return $this->complexity;
+    }
+
+    public function hasRestriction(string $restriction): bool
+    {
+        return in_array($restriction, $this->restrictions, true);
+    }
+}
diff --git a/.archive/Archived/CacheComplexity.php b/.archive/Archived/CacheComplexity.php
new file mode 100644
index 00000000..32a18dc6
--- /dev/null
+++ b/.archive/Archived/CacheComplexity.php
@@ -0,0 +1,12 @@
+<?php
+declare(strict_types=1);
+
+namespace Archive\Archived;
+
+enum CacheComplexity: string
+{
+    case LOW = 'low';
+    case MEDIUM = 'medium';
+    case HIGH = 'high';
+    case EXTREME = 'extreme';
+}
diff --git a/.archive/Archived/CacheStrategy.php b/.archive/Archived/CacheStrategy.php
new file mode 100644
index 00000000..eae46300
--- /dev/null
+++ b/.archive/Archived/CacheStrategy.php
@@ -0,0 +1,41 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Archive\Archived;
+
+enum CacheStrategy: string
+{
+    case STATIC = 'static';
+    case PARTIAL = 'partial';
+    case FRAGMENT = 'fragment';
+    case DYNAMIC = 'dynamic';
+    case DISABLED = 'disabled';
+
+    public function getTtl(): int
+    {
+        return match($this) {
+            self::STATIC => 3600,    // 1 Stunde für statische Inhalte
+            self::PARTIAL => 900,    // 15 Minuten für teilweise dynamische Inhalte
+            self::FRAGMENT => 300,   // 5 Minuten für Fragment-Cache
+            self::DYNAMIC => 0,      // Keine Caching für dynamische Inhalte
+            self::DISABLED => 0,     // Caching deaktiviert
+        };
+    }
+
+    public function getPriority(): int
+    {
+        return match($this) {
+            self::STATIC => 1,
+            self::PARTIAL => 2,
+            self::FRAGMENT => 3,
+            self::DYNAMIC => 4,
+            self::DISABLED => 5,
+        };
+    }
+
+    public function shouldCache(): bool
+    {
+        return $this !== self::DYNAMIC && $this !== self::DISABLED;
+    }
+}
diff --git a/.archive/Archived/CacheWarmer.php b/.archive/Archived/CacheWarmer.php
new file mode 100644
index 00000000..95f27efc
--- /dev/null
+++ b/.archive/Archived/CacheWarmer.php
@@ -0,0 +1,64 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Archive\Archived;
+
+use App\Framework\View\RenderContext;
+
+final class CacheWarmer
+{
+    private array $popularTemplates = [];
+
+    public function __construct(
+        private readonly SmartCacheEngine $cacheEngine,
+        private readonly array $warmupTemplates = []
+    ) {}
+
+    public function warmupTemplates(array $templates = []): array
+    {
+        $templatesToWarm = !empty($templates) ? $templates : $this->warmupTemplates;
+        $results = [];
+
+        foreach ($templatesToWarm as $template => $data) {
+            $startTime = microtime(true);
+
+            try {
+                $context = new RenderContext($template, $data ?? []);
+                $this->cacheEngine->render($context);
+
+                $duration = microtime(true) - $startTime;
+                $results[$template] = [
+                    'success' => true,
+                    'duration' => round($duration * 1000, 2) . 'ms'
+                ];
+
+            } catch (\Exception $e) {
+                $results[$template] = [
+                    'success' => false,
+                    'error' => $e->getMessage()
+                ];
+            }
+        }
+
+        return $results;
+    }
+
+    public function addPopularTemplate(string $template, array $data = []): void
+    {
+        $this->popularTemplates[$template] = $data;
+    }
+
+    public function warmupPopularTemplates(): array
+    {
+        return $this->warmupTemplates($this->popularTemplates);
+    }
+
+    public function scheduleWarmup(array $templates): void
+    {
+        // In einer echten Implementierung könnte hier ein Background-Job gescheduled werden
+        foreach ($templates as $template => $data) {
+            $this->addPopularTemplate($template, $data);
+        }
+    }
+}
diff --git a/.archive/Archived/CacheabilityInfo.php b/.archive/Archived/CacheabilityInfo.php
new file mode 100644
index 00000000..7e722d7b
--- /dev/null
+++ b/.archive/Archived/CacheabilityInfo.php
@@ -0,0 +1,75 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Archive\Archived;
+
+final class CacheabilityInfo
+{
+    public bool $hasDynamicComponents = false;
+    public bool $hasUserSpecificContent = false;
+    public bool $hasFormElements = false;
+    public bool $hasTimeBasedContent = false;
+    public bool $hasSessionData = false;
+    public array $staticFragments = [];
+    public array $dynamicFragments = [];
+    public array $dynamicComponents = [];
+    public CacheStrategy $cacheStrategy = CacheStrategy::DYNAMIC;
+    public int $ttl = 0;
+    public array $dependencies = [];
+
+    public function isFullyCacheable(): bool
+    {
+        return !$this->hasDynamicComponents
+            && !$this->hasUserSpecificContent
+            && !$this->hasFormElements
+            && !$this->hasSessionData
+            && !$this->hasTimeBasedContent;
+    }
+
+    public function isPartiallyCacheable(): bool
+    {
+        return count($this->staticFragments) > 0 && !$this->hasUserSpecificContent;
+    }
+
+    public function shouldUseFragmentCache(): bool
+    {
+        return count($this->staticFragments) > 0 || count($this->dynamicFragments) > 0;
+    }
+
+    public function getCacheComplexity(): int
+    {
+        $complexity = 0;
+        $complexity += count($this->staticFragments);
+        $complexity += count($this->dynamicFragments) * 3;
+        $complexity += $this->hasUserSpecificContent ? 5 : 0;
+        $complexity += $this->hasFormElements ? 3 : 0;
+        $complexity += $this->hasDynamicComponents ? 4 : 0;
+
+        return $complexity;
+    }
+
+    public function addStaticFragment(string $fragmentId): void
+    {
+        if (!in_array($fragmentId, $this->staticFragments, true)) {
+            $this->staticFragments[] = $fragmentId;
+        }
+    }
+
+    public function addDynamicFragment(string $fragmentId): void
+    {
+        if (!in_array($fragmentId, $this->dynamicFragments, true)) {
+            $this->dynamicFragments[] = $fragmentId;
+        }
+    }
+
+    public function hasFragments(): bool
+    {
+        return count($this->staticFragments) > 0 || count($this->dynamicFragments) > 0;
+    }
+
+    public function getFragmentCount(): int
+    {
+        return count($this->staticFragments) + count($this->dynamicFragments);
+    }
+}
diff --git a/.archive/Archived/DependencyCollection.php b/.archive/Archived/DependencyCollection.php
new file mode 100644
index 00000000..c821c3fd
--- /dev/null
+++ b/.archive/Archived/DependencyCollection.php
@@ -0,0 +1,93 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Archive\Archived;
+
+use App\Framework\View\Cache\CacheDependency;
+use App\Framework\View\Cache\DependencyType;
+
+final readonly class DependencyCollection
+{
+    /** @param CacheDependency[] $dependencies */
+    public function __construct(
+        private array $dependencies = [],
+    ) {
+        foreach ($dependencies as $dependency) {
+            if (!$dependency instanceof CacheDependency) {
+                throw new \InvalidArgumentException('All items must be CacheDependency instances');
+            }
+        }
+    }
+
+    public static function empty(): self
+    {
+        return new self([]);
+    }
+
+    public static function fromStrings(array $strings): self
+    {
+        $dependencies = array_map(
+            fn(string $str) => CacheDependency::fromString($str),
+            $strings
+        );
+
+        return new self($dependencies);
+    }
+
+    public function add(CacheDependency $dependency): self
+    {
+        // Prevent duplicates
+        foreach ($this->dependencies as $existing) {
+            if ($existing->equals($dependency)) {
+                return $this;
+            }
+        }
+
+        return new self([...$this->dependencies, $dependency]);
+    }
+
+    public function has(string $key): bool
+    {
+        foreach ($this->dependencies as $dependency) {
+            if ($dependency->key === $key) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public function ofType(DependencyType $type): self
+    {
+        return new self(
+            array_filter(
+                $this->dependencies,
+                fn(CacheDependency $dep) => $dep->type === $type
+            )
+        );
+    }
+
+    public function count(): int
+    {
+        return count($this->dependencies);
+    }
+
+    public function isEmpty(): bool
+    {
+        return empty($this->dependencies);
+    }
+
+    public function toArray(): array
+    {
+        return array_map(
+            fn(CacheDependency $dep) => $dep->toArray(),
+            $this->dependencies
+        );
+    }
+
+    /** @return CacheDependency[] */
+    public function all(): array
+    {
+        return $this->dependencies;
+    }
+}
diff --git a/.archive/Archived/FragmentCacheManager.php b/.archive/Archived/FragmentCacheManager.php
new file mode 100644
index 00000000..50dfe386
--- /dev/null
+++ b/.archive/Archived/FragmentCacheManager.php
@@ -0,0 +1,93 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Archive\Archived;
+
+use App\Framework\Cache\Cache;
+
+final readonly class FragmentCacheManager
+{
+    public function __construct(
+        private Cache $cache,
+    ) {}
+
+    public function hasFragment(string $key, array $dependencies = [], int $ttl = 300): bool
+    {
+        $cacheKey = $this->buildFragmentKey($key, $dependencies);
+        return $this->cache->has($cacheKey);
+    }
+
+    public function cacheFragment(string $key, callable $generator, array $dependencies = [], int $ttl = 300): string
+    {
+        $cacheKey = $this->buildFragmentKey($key, $dependencies);
+
+        return $this->cache->remember(
+            $cacheKey,
+            $generator,
+            $ttl
+        )->value;
+    }
+
+    public function cacheStaticFragment(string $fragmentId, string $content, array $dependencies = []): void
+    {
+        $cacheKey = $this->buildFragmentKey($fragmentId, $dependencies);
+
+        // Statische Fragmente haben lange TTL
+        $this->cache->set($cacheKey, $content, 3600);
+    }
+
+    public function getDynamicFragment(string $fragmentId, callable $generator, array $context = []): string
+    {
+        // Dynamische Fragmente werden nicht gecacht, aber durch den Generator optimiert
+        return $generator($context);
+    }
+
+    public function invalidateFragment(string $key, array $dependencies = []): void
+    {
+        $cacheKey = $this->buildFragmentKey($key, $dependencies);
+        $this->cache->forget($cacheKey);
+    }
+
+    public function invalidateByPattern(string $pattern): int
+    {
+        // Vereinfacht - das Cache-Interface bietet möglicherweise keine Pattern-Invalidierung
+        // Hier könnten wir eine erweiterte Implementierung hinzufügen
+        return 0;
+    }
+
+    public function getFragment(string $key, array $dependencies = []): ?string
+    {
+        $cacheKey = $this->buildFragmentKey($key, $dependencies);
+
+        if ($this->cache->has($cacheKey)) {
+            return $this->cache->get($cacheKey)->value;
+        }
+
+        return null;
+    }
+
+    public function warmupFragment(string $key, callable $generator, array $dependencies = [], int $ttl = 300): void
+    {
+        $this->cacheFragment($key, $generator, $dependencies, $ttl);
+    }
+
+    public function getFragmentStats(): array
+    {
+        return [
+            'cache_enabled' => true,
+            'cache_interface' => get_class($this->cache),
+        ];
+    }
+
+    private function buildFragmentKey(string $key, array $dependencies): string
+    {
+        $dependencyHash = '';
+        if (!empty($dependencies)) {
+            ksort($dependencies); // Konsistente Reihenfolge
+            $dependencyHash = ':' . md5(serialize($dependencies));
+        }
+
+        return "fragment:{$key}{$dependencyHash}";
+    }
+}
diff --git a/.archive/Archived/SmartCacheEngine.php b/.archive/Archived/SmartCacheEngine.php
new file mode 100644
index 00000000..ed4003b0
--- /dev/null
+++ b/.archive/Archived/SmartCacheEngine.php
@@ -0,0 +1,428 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Archive\Archived;
+
+use App\Framework\Cache\Cache;
+use App\Framework\View\DomWrapper;
+use App\Framework\View\Loading\TemplateLoader;
+use App\Framework\View\RenderContext;
+use App\Framework\View\TemplateProcessor;
+use App\Framework\View\TemplateRenderer;
+
+final class SmartCacheEngine implements TemplateRenderer
+{
+    private array $cacheStats = [
+        'hits' => 0,
+        'misses' => 0,
+        'renders' => 0,
+        'cached_templates' => [],
+    ];
+
+    public function __construct(
+        private readonly TemplateLoader       $loader,
+        private readonly TemplateAnalyzer     $analyzer,
+        private readonly FragmentCacheManager $fragmentCache,
+        private readonly Cache                $cache,
+        private readonly TemplateProcessor    $processor = new TemplateProcessor(),
+        private readonly bool                 $cacheEnabled = true,
+        private readonly bool                 $debugMode = true,
+        private readonly TemplatePreprocessor $preprocessor = new TemplatePreprocessor(),
+    ) {
+        dd('oldcacheengine');
+    }
+
+    public function render(RenderContext $context): string
+    {
+        $this->cacheStats['renders']++;
+
+        if (!$this->cacheEnabled) {
+            $this->logDebug("Cache disabled - rendering without cache", $context);
+            return $this->renderWithoutCache($context);
+        }
+
+        $startTime = microtime(true);
+
+        // Lade und analysiere Template
+        $template = $this->loader->load($context->template, $context->controllerClass, $context);
+
+        // Preprocessing für optimierte Cache-Keys
+        $normalizedTemplate = $this->preprocessor->normalizeTemplate($template, $context);
+        $cacheableBlocks = $this->preprocessor->extractCacheableBlocks($template);
+
+        $analysis = $this->analyzer->analyzeCacheability($normalizedTemplate, $context);
+
+        // Erweitere Analysis mit extrahierten Blöcken
+        foreach ($cacheableBlocks as $block) {
+            if ($block['type'] === 'explicit') {
+                $analysis->addStaticFragment($block['id']);
+            }
+        }
+
+        $this->logDebug("Template loaded, length: " . strlen($template) . " chars", $context);
+        $this->logDebug("Cache strategy: {$analysis->cacheStrategy->value}, TTL: {$analysis->ttl}s", $context);
+        $this->logDebug("Cacheable blocks found: " . count($cacheableBlocks), $context);
+
+        $result = match($analysis->cacheStrategy) {
+            CacheStrategy::STATIC => $this->renderStaticCached($context, $template, $analysis),
+            CacheStrategy::PARTIAL => $this->renderPartialCached($context, $template, $analysis),
+            CacheStrategy::FRAGMENT => $this->renderFragmentCached($context, $template, $analysis),
+            CacheStrategy::DYNAMIC => $this->processor->render($context, $template),
+            CacheStrategy::DISABLED => $this->renderWithoutCache($context),
+        };
+
+        $renderTime = microtime(true) - $startTime;
+        $this->logCachePerformance($context, $analysis, $renderTime);
+
+        return $result;
+    }
+
+    private function renderStaticCached(RenderContext $context, string $template, CacheabilityInfo $analysis): string
+    {
+        $cacheKey = $this->buildStaticCacheKey($context, $analysis);
+
+        // Prüfe zuerst, ob bereits im Cache
+        $wasInCache = $this->cache->has($cacheKey);
+
+        // Nutze remember-Pattern
+        $cacheItem = $this->cache->remember(
+            $cacheKey,
+            function() use ($context, $template) {
+                $this->logDebug("CACHE MISS - Generating new content", $context);
+                $this->cacheStats['misses']++;
+                return $this->processor->render($context, $template);
+            },
+            $analysis->ttl
+        );
+
+        if ($wasInCache) {
+            $this->logDebug("CACHE HIT - Using cached content", $context);
+            $this->cacheStats['hits']++;
+        }
+
+        $this->cacheStats['cached_templates'][$context->template] = [
+            'strategy' => 'static',
+            'key' => $cacheKey,
+            'ttl' => $analysis->ttl,
+            'hit' => $wasInCache
+        ];
+
+        return $cacheItem->value;
+    }
+
+    private function renderPartialCached(RenderContext $context, string $template, CacheabilityInfo $analysis): string
+    {
+        $cacheKey = $this->buildPartialCacheKey($context, $analysis);
+        $wasInCache = $this->cache->has($cacheKey);
+
+        $cacheItem = $this->cache->remember(
+            $cacheKey,
+            function() use ($context, $template) {
+                $this->cacheStats['misses']++;
+                return $this->processor->render($context, $template);
+            },
+            $analysis->ttl
+        );
+
+        if ($wasInCache) {
+            $this->cacheStats['hits']++;
+        }
+
+        return $cacheItem->value;
+    }
+
+    private function renderFragmentCached(RenderContext $context, string $template, CacheabilityInfo $analysis): string
+    {
+        // Wenn keine Fragmente erkannt wurden, verwende ein Template-weites Fragment
+        if (empty($analysis->staticFragments) && empty($analysis->dynamicFragments)) {
+            $this->logDebug("No fragments found - creating template-wide fragment", $context);
+
+            $templateFragmentKey = "template_{$context->template}";
+            $wasInCache = $this->fragmentCache->hasFragment($templateFragmentKey, $analysis->dependencies ?? [], $analysis->ttl);
+
+            if ($wasInCache) {
+                $this->logDebug("FRAGMENT HIT - Using cached template", $context);
+                $this->cacheStats['hits']++;
+                $content = $this->fragmentCache->getFragment($templateFragmentKey, $analysis->dependencies ?? []);
+            } else {
+                $this->logDebug("FRAGMENT MISS - Generating new template content", $context);
+                $this->cacheStats['misses']++;
+                $content = $this->fragmentCache->cacheFragment(
+                    $templateFragmentKey,
+                    function() use ($context, $template) {
+                        return $this->processor->render($context, $template);
+                    },
+                    $analysis->dependencies ?? [],
+                    $analysis->ttl
+                );
+            }
+
+            $this->cacheStats['cached_templates'][$context->template] = [
+                'strategy' => 'fragment',
+                'key' => $templateFragmentKey,
+                'ttl' => $analysis->ttl,
+                'hit' => $wasInCache
+            ];
+
+                // Request-spezifische Statistiken
+                $hitRate = $this->cacheStats['hits'] + $this->cacheStats['misses'] > 0
+                    ? round(($this->cacheStats['hits'] / ($this->cacheStats['hits'] + $this->cacheStats['misses'])) * 100, 1)
+                    : 0;
+
+                error_log("SmartCache Request Stats: Hits: " . $this->cacheStats['hits'] . ", Misses: " . $this->cacheStats['misses'] . ", Hit Rate: {$hitRate}%");
+
+            return $content;
+        } else {
+            $this->logDebug("Found " . count($analysis->staticFragments) . " static fragments and " . count($analysis->dynamicFragments) . " dynamic fragments", $context);
+        }
+
+        // Verarbeite explizite Fragmente
+        $finalContent = '';
+
+        foreach ($analysis->staticFragments as $fragmentId) {
+            $wasInCache = $this->fragmentCache->hasFragment($fragmentId, $analysis->dependencies ?? [], $analysis->ttl);
+
+            if ($wasInCache) {
+                $this->logDebug("FRAGMENT HIT - Using cached fragment: {$fragmentId}", $context);
+                $this->cacheStats['hits']++;
+                // Direkt aus Cache holen ohne Generator zu verwenden
+                $fragmentContent = $this->fragmentCache->getFragment($fragmentId, $analysis->dependencies ?? []);
+            } else {
+                $this->logDebug("FRAGMENT MISS - Generating fragment: {$fragmentId}", $context);
+                $this->cacheStats['misses']++;
+                $fragmentContent = $this->fragmentCache->cacheFragment(
+                    $fragmentId,
+                    function() use ($fragmentId, $template, $context) {
+                        return $this->renderFragmentFromTemplate($fragmentId, $template, $context);
+                    },
+                    $analysis->dependencies ?? [],
+                    $analysis->ttl
+                );
+            }
+
+            $finalContent .= $fragmentContent;
+        }
+
+        // Rendere dynamische Fragmente ohne Caching
+        foreach ($analysis->dynamicFragments as $fragmentId) {
+            $fragmentContent = $this->renderFragmentFromTemplate($fragmentId, $template, $context);
+            $finalContent .= $fragmentContent;
+        }
+
+        return $finalContent ?: $this->processor->render($context, $template);
+    }
+
+    private function renderFragmentFromTemplate(string $fragmentId, string $template, RenderContext $context): string
+    {
+        // Für jetzt: Wenn es ein Template-Fragment ist, rendere das komplette Template
+        if (str_starts_with($fragmentId, 'template_')) {
+            return $this->processor->render($context, $template);
+        }
+
+        // TODO: Hier könnten wir später spezifische Fragment-Extraktion implementieren
+        // Für jetzt verwende DOM-Wrapper für Fragment-Extraktion
+        try {
+            $domWrapper = DomWrapper::fromString($template);
+            return $this->renderFragment($fragmentId, $domWrapper, $context);
+        } catch (\Exception $e) {
+            $this->logDebug("Fragment rendering failed for {$fragmentId}: " . $e->getMessage(), $context);
+            // Fallback: Rendere komplettes Template
+            return $this->processor->render($context, $template);
+        }
+    }
+
+    private function renderWithoutCache(RenderContext $context): string
+    {
+        $template = $this->loader->load($context->template, $context->controllerClass, $context);
+        return $this->processor->render($context, $template);
+    }
+
+    private function renderFragment(string $fragmentId, DomWrapper $domWrapper, RenderContext $context): string
+    {
+        // Vereinfachte Fragment-Rendering-Logik
+        // In einer vollständigen Implementierung würde hier das spezifische Fragment extrahiert
+        $elements = $domWrapper->getElementsByAttribute('data-fragment-id', $fragmentId);
+
+        if (count($elements) > 0) {
+            $element = $elements[0];
+            return $domWrapper->document->saveHTML($element);
+        }
+
+        return '';
+    }
+
+    private function extractStaticContent(string $content, CacheabilityInfo $analysis): string
+    {
+        // Entferne dynamische Platzhalter für statisches Caching
+        $staticContent = $content;
+
+        // Ersetze dynamische Teile mit Platzhaltern
+        $staticContent = preg_replace('/\{\{[^}]+}}/', '{{DYNAMIC_PLACEHOLDER}}', $staticContent);
+
+        return $staticContent;
+    }
+
+    private function buildStaticCacheKey(RenderContext $context, $analysis): string
+    {
+        $dependencies = is_object($analysis) && method_exists($analysis, 'dependencies')
+            ? $analysis->dependencies
+            : ($analysis->dependencies ?? []);
+
+        $optimizedKey = $this->preprocessor->generateOptimizedCacheKey($context, $dependencies);
+
+        return "static:{$optimizedKey}";
+    }
+
+    private function buildPartialCacheKey(RenderContext $context, $analysis): string
+    {
+        $dependencies = is_object($analysis) && method_exists($analysis, 'dependencies')
+            ? $analysis->dependencies
+            : ($analysis->dependencies ?? []);
+
+        $optimizedKey = $this->preprocessor->generateOptimizedCacheKey($context, $dependencies);
+
+        return "partial:{$optimizedKey}";
+    }
+
+
+    public function getCacheStats(): array
+    {
+        $hitRate = $this->cacheStats['hits'] + $this->cacheStats['misses'] > 0
+            ? round(($this->cacheStats['hits'] / ($this->cacheStats['hits'] + $this->cacheStats['misses'])) * 100, 2)
+            : 0;
+
+        return [
+            'smart_cache' => [
+                'enabled' => $this->cacheEnabled,
+                'debug_mode' => $this->debugMode,
+                'cache_interface' => get_class($this->cache),
+                'performance' => [
+                    'total_renders' => $this->cacheStats['renders'],
+                    'cache_hits' => $this->cacheStats['hits'],
+                    'cache_misses' => $this->cacheStats['misses'],
+                    'hit_rate' => $hitRate . '%',
+                ],
+                'cached_templates' => $this->cacheStats['cached_templates'],
+                'fragment_stats' => $this->fragmentCache->getFragmentStats(),
+            ]
+        ];
+    }
+
+
+    public function invalidateCache(?string $template = null): int
+    {
+        $invalidated = 0;
+
+        if ($template) {
+            // Invalidiere spezifisches Template
+            $patterns = [
+                "static:{$template}:",
+                "partial:{$template}:",
+                "template_{$template}",
+            ];
+
+            foreach ($patterns as $pattern) {
+                // Vereinfachte Implementierung - da das Cache-Interface keine Pattern-Suche unterstützt
+                // könnte hier eine erweiterte Lösung implementiert werden
+                $invalidated++;
+            }
+        } else {
+            // Alle Caches löschen und Stats zurücksetzen
+            if ($this->cache->clear()) {
+                $this->resetStats();
+                $invalidated = 1;
+            }
+        }
+
+        return $invalidated;
+    }
+
+    public function resetStats(): void
+    {
+        $this->cacheStats = [
+            'hits' => 0,
+            'misses' => 0,
+            'renders' => 0,
+            'cached_templates' => [],
+        ];
+    }
+
+    public function warmupCache(array $templates = []): array
+    {
+        if (!$this->warmer) {
+            return ['error' => 'CacheWarmer not configured'];
+        }
+
+        return $this->warmer->warmupTemplates($templates);
+    }
+
+    public function addPopularTemplate(string $template, array $data = []): void
+    {
+        if ($this->warmer) {
+            $this->warmer->addPopularTemplate($template, $data);
+        }
+    }
+
+    public function diagnoseCaching(): void
+    {
+        echo "\n=== CACHE DIAGNOSTICS ===\n";
+        echo "Smart Cache Enabled: " . ($this->cacheEnabled ? 'YES' : 'NO') . "\n";
+        echo "Cache Interface: " . get_class($this->cache) . "\n";
+        echo "Debug Mode: " . ($this->debugMode ? 'YES' : 'NO') . "\n";
+        echo "Total Renders: " . $this->cacheStats['renders'] . "\n";
+        echo "Cache Hits: " . $this->cacheStats['hits'] . "\n";
+        echo "Cache Misses: " . $this->cacheStats['misses'] . "\n";
+
+        $hitRate = $this->cacheStats['hits'] + $this->cacheStats['misses'] > 0
+            ? round(($this->cacheStats['hits'] / ($this->cacheStats['hits'] + $this->cacheStats['misses'])) * 100, 2)
+            : 0;
+        echo "Hit Rate: " . $hitRate . "%\n";
+
+        echo "\n=== ANALYSIS ===\n";
+        if ($this->cacheStats['hits'] === 0 && $this->cacheStats['misses'] === 0) {
+            echo "⚠️  PROBLEM: No cache operations detected!\n";
+            echo "   This suggests that templates are being rendered with CacheStrategy::DYNAMIC or CacheStrategy::DISABLED\n";
+            echo "   Check the TemplateAnalyzer logic to ensure templates are being marked as cacheable.\n";
+        }
+
+        echo "========================\n";
+    }
+
+    private function logCachePerformance(RenderContext $context, CacheabilityInfo $analysis, float $renderTime): void
+    {
+        if (!$this->debugMode) {
+            return;
+        }
+
+        $logData = [
+            'template' => $context->template,
+            'strategy' => $analysis->cacheStrategy->value,
+            'render_time' => round($renderTime * 1000, 2) . 'ms',
+            'complexity' => $analysis->getCacheComplexity(),
+            'cacheable' => $analysis->cacheStrategy->shouldCache(),
+                'request_hits' => $this->cacheStats['hits'],
+                'request_misses' => $this->cacheStats['misses'],
+            'static_fragments' => count($analysis->staticFragments),
+            'dynamic_fragments' => count($analysis->dynamicFragments),
+            'ttl' => $analysis->ttl,
+        ];
+
+        error_log('SmartCache Performance: ' . json_encode($logData));
+
+        // Zusätzliche Fragment-Details wenn Fragment-Strategy
+        if ($analysis->cacheStrategy === CacheStrategy::FRAGMENT) {
+            error_log('SmartCache Fragments: static=[' . implode(',', $analysis->staticFragments) .
+                     '] dynamic=[' . implode(',', $analysis->dynamicFragments) . ']');
+        }
+    }
+
+    private function logDebug(string $message, RenderContext $context): void
+    {
+        if (!$this->debugMode) {
+            return;
+        }
+
+        error_log("SmartCache DEBUG [{$context->template}]: {$message}");
+    }
+}
diff --git a/.archive/Archived/TemplateAnalyzer.php b/.archive/Archived/TemplateAnalyzer.php
new file mode 100644
index 00000000..81a87197
--- /dev/null
+++ b/.archive/Archived/TemplateAnalyzer.php
@@ -0,0 +1,216 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Archive\Archived;
+
+use App\Framework\View\RenderContext;
+
+final readonly class TemplateAnalyzer
+{
+    private const array DYNAMIC_COMPONENTS = [
+        'user-info', 'session-data', 'csrf-token', 'timestamp',
+        'user-menu', 'cart', 'notifications', 'live-data'
+    ];
+
+    private const array TIME_BASED_PATTERNS = [
+        'data-timestamp', 'data-live', 'data-realtime',
+        'class="live"', 'class="timestamp"'
+    ];
+
+    public function analyzeCacheability(string $template, RenderContext $context): CacheabilityInfo
+    {
+        $analysis = new CacheabilityInfo();
+
+        try {
+            // Einfache String-basierte Analyse für bessere Kompatibilität
+            $analysis->hasDynamicComponents = $this->findDynamicComponentsInString($template, $analysis);
+            $analysis->hasUserSpecificContent = $this->findUserContentInString($template, $context);
+            $analysis->hasFormElements = $this->findFormsInString($template);
+            $analysis->hasTimeBasedContent = $this->findTimeBasedContent($template);
+            $analysis->hasSessionData = $this->findSessionData($template, $context);
+
+            // Fragment-Analyse hinzufügen
+            $this->autoDetectFragments($template, $analysis);
+
+            // Bestimme beste Cache-Strategie
+            $analysis->cacheStrategy = $this->determineBestStrategy($analysis);
+            $analysis->ttl = $this->calculateOptimalTtl($analysis);
+            $analysis->dependencies = $this->identifyDependencies($analysis, $context);
+
+        } catch (\Exception $e) {
+            // Bei Fehlern: Konservativ statisches Caching
+            $analysis->cacheStrategy = CacheStrategy::STATIC;
+            $analysis->ttl = 300;
+        }
+
+        return $analysis;
+    }
+
+    private function findDynamicComponentsInString(string $template, CacheabilityInfo $analysis): bool
+    {
+        $hasDynamic = false;
+        foreach (self::DYNAMIC_COMPONENTS as $component) {
+            if (str_contains($template, $component)) {
+                $analysis->dynamicComponents[] = $component;
+                $hasDynamic = true;
+            }
+        }
+        return $hasDynamic;
+    }
+
+    private function findUserContentInString(string $template, RenderContext $context): bool
+    {
+        // Suche nach user-spezifischen Patterns
+        $userPatterns = ['{{user', '$user', 'data-user', 'class="user-'];
+
+        if (array_any($userPatterns, fn($pattern) => str_contains($template, $pattern))) {
+            return true;
+        }
+
+        // Prüfe Context-Daten auf User-Informationen
+        return isset($context->data['user']) || isset($context->data['session']);
+    }
+
+    private function findFormsInString(string $template): bool
+    {
+        return str_contains($template, '<form') || str_contains($template, 'csrf') || str_contains($template, 'token');
+    }
+
+    // Entfernte Methoden werden durch die neuen String-basierten Methoden ersetzt
+
+    private function findTimeBasedContent(string $template): bool
+    {
+        return array_any(self::TIME_BASED_PATTERNS, fn($pattern) => str_contains($template, $pattern));
+    }
+
+    private function findSessionData(string $template, RenderContext $context): bool
+    {
+        // Prüfe auf Session-bezogene Patterns im Template
+        $sessionPatterns = ['session.', '{{session', '$session', 'data-session'];
+
+        if (array_any($sessionPatterns, fn($pattern) => str_contains($template, $pattern))) {
+            return true;
+        }
+
+        // Prüfe Context auf Session-Daten
+        return isset($context->data['session']) || isset($context->data['flash']);
+    }
+
+    // Fragment-Analyse vereinfacht entfernt für bessere Stabilität
+
+    private function determineBestStrategy(CacheabilityInfo $analysis): CacheStrategy
+    {
+        // Vollständig statisch
+        if ($analysis->isFullyCacheable()) {
+            return CacheStrategy::STATIC;
+        }
+
+        // Teilweise cacheable mit Fragmenten
+        if ($analysis->shouldUseFragmentCache()) {
+            return CacheStrategy::FRAGMENT;
+        }
+
+        // Teilweise cacheable ohne Fragmente
+        if ($analysis->isPartiallyCacheable()) {
+            return CacheStrategy::PARTIAL;
+        }
+
+        // Vollständig dynamisch
+        return CacheStrategy::DYNAMIC;
+    }
+
+    private function calculateOptimalTtl(CacheabilityInfo $analysis): int
+    {
+        $baseTtl = $analysis->cacheStrategy->getTtl();
+
+        // Reduziere TTL basierend auf Komplexität
+        $complexity = $analysis->getCacheComplexity();
+        $reduction = min($complexity * 60, $baseTtl * 0.5); // Max 50% Reduktion
+
+        return max(0, $baseTtl - (int)$reduction);
+    }
+
+    private function identifyDependencies(CacheabilityInfo $analysis, RenderContext $context): array
+    {
+        $dependencies = [];
+
+        // Template-File als Basis-Dependency
+        $dependencies['template'] = $context->template;
+
+        // Dynamic Fragment Dependencies - verwende dynamicFragments anstatt dynamicComponents
+        foreach ($analysis->dynamicFragments as $fragment) {
+            // Verwende einfach den Fragment-Namen und aktuellen Timestamp
+            $dependencies['fragment:' . $fragment] = time();
+        }
+
+        // User-spezifische Dependencies
+        if ($analysis->hasUserSpecificContent && isset($context->data['user']['id'])) {
+            $dependencies['user'] = $context->data['user']['id'];
+        }
+
+        return $dependencies;
+    }
+
+    private function autoDetectFragments(string $template, CacheabilityInfo $info): void
+    {
+        $fragmentsFound = false;
+
+        // Erkenne große statische Blöcke (Navigation, Footer, etc.)
+        if (preg_match('/<nav[^>]*>(.*?)<\/nav>/s', $template)) {
+            $info->addStaticFragment('navigation');
+            $fragmentsFound = true;
+        }
+
+        if (preg_match('/<footer[^>]*>(.*?)<\/footer>/s', $template)) {
+            $info->addStaticFragment('footer');
+            $fragmentsFound = true;
+        }
+
+        if (preg_match('/<header[^>]*>(.*?)<\/header>/s', $template)) {
+            $info->addStaticFragment('header');
+            $fragmentsFound = true;
+        }
+
+        // Erkenne HTML-Sektionen
+        if (preg_match('/<section[^>]*>(.*?)<\/section>/s', $template)) {
+            $info->addStaticFragment('content_section');
+            $fragmentsFound = true;
+        }
+
+        if (preg_match('/<main[^>]*>(.*?)<\/main>/s', $template)) {
+            $info->addStaticFragment('main_content');
+            $fragmentsFound = true;
+        }
+
+        // Erkenne CSS-Klassen-basierte Bereiche
+        if (preg_match('/class=["\'].*sidebar.*["\']/', $template)) {
+            $info->addStaticFragment('sidebar');
+            $fragmentsFound = true;
+        }
+
+        // Erkenne dynamische Bereiche
+        if (preg_match('/\{\{\s*flash|errors|session/', $template)) {
+            $info->addDynamicFragment('user_messages');
+            $fragmentsFound = true;
+        }
+
+        // Analysiere Template-Komplexität
+        $dynamicMatches = preg_match_all('/\{\{[^}]+}}/', $template);
+        $templateLength = strlen($template);
+
+        // Debugging der Fragment-Erkennung
+        error_log("TemplateAnalyzer DEBUG: Template length: {$templateLength}, Dynamic matches: {$dynamicMatches}, Fragments found: " . ($fragmentsFound ? 'yes' : 'no'));
+
+        // Wenn weniger als 5 dynamische Platzhalter pro 1_000 Zeichen UND keine anderen Fragmente
+        $dynamicDensity = $templateLength > 0 ? ($dynamicMatches / $templateLength) * 1000 : 0;
+
+        error_log("TemplateAnalyzer DEBUG: Dynamic density: {$dynamicDensity}, Has dynamic components: " . ($info->hasDynamicComponents ? 'yes' : 'no'));
+
+        // Immer ein template_main Fragment hinzufügen wenn wenig dynamische Inhalte
+        if ($dynamicDensity < 5 || (!$fragmentsFound && !$info->hasDynamicComponents)) {
+            $info->addStaticFragment('template_main');
+            error_log("TemplateAnalyzer DEBUG: Added template_main fragment (density: {$dynamicDensity})");
+        }
+    }
+}
diff --git a/.archive/Archived/TemplateContent.php b/.archive/Archived/TemplateContent.php
new file mode 100644
index 00000000..c2815ba1
--- /dev/null
+++ b/.archive/Archived/TemplateContent.php
@@ -0,0 +1,56 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Archive\Archived;
+
+final readonly class TemplateContent
+{
+    public function __construct(
+        public string $rawTemplate,
+        public bool $hasUserSpecificContent = false,
+        public bool $hasSessionData = false,
+        public bool $hasFormElements = false,
+        public bool $hasTimeBasedContent = false,
+        public bool $hasRandomContent = false,
+        public bool $hasCsrfTokens = false,
+        public array $dynamicVariables = [],
+        public array $staticBlocks = [],
+    ) {}
+
+    public function hasDynamicContent(): bool
+    {
+        return $this->hasUserSpecificContent
+            || $this->hasSessionData
+            || $this->hasFormElements
+            || $this->hasTimeBasedContent
+            || $this->hasRandomContent
+            || $this->hasCsrfTokens
+            || !empty($this->dynamicVariables);
+    }
+
+    public function getDynamicContentTypes(): array
+    {
+        $types = [];
+
+        if ($this->hasUserSpecificContent) $types[] = 'user_specific';
+        if ($this->hasSessionData) $types[] = 'session_data';
+        if ($this->hasFormElements) $types[] = 'form_elements';
+        if ($this->hasTimeBasedContent) $types[] = 'time_based';
+        if ($this->hasRandomContent) $types[] = 'random_content';
+        if ($this->hasCsrfTokens) $types[] = 'csrf_tokens';
+
+        return $types;
+    }
+
+    public function getCharacteristics(): array
+    {
+        return [
+            'has_dynamic_content' => $this->hasDynamicContent(),
+            'dynamic_types' => $this->getDynamicContentTypes(),
+            'dynamic_variables_count' => count($this->dynamicVariables),
+            'static_blocks_count' => count($this->staticBlocks),
+            'template_size' => strlen($this->rawTemplate),
+        ];
+    }
+}
diff --git a/.archive/Archived/TemplatePreprocessor.php b/.archive/Archived/TemplatePreprocessor.php
new file mode 100644
index 00000000..246f269f
--- /dev/null
+++ b/.archive/Archived/TemplatePreprocessor.php
@@ -0,0 +1,108 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Archive\Archived;
+
+use App\Framework\View\RenderContext;
+
+final class TemplatePreprocessor
+{
+    private array $normalizedTemplates = [];
+
+    public function normalizeTemplate(string $template, RenderContext $context): string
+    {
+        $cacheKey = md5($template . serialize($context->data));
+
+        if (isset($this->normalizedTemplates[$cacheKey])) {
+            return $this->normalizedTemplates[$cacheKey];
+        }
+
+        $normalized = $template;
+
+        // Entferne Kommentare für konsistentere Cache-Keys
+        $normalized = preg_replace('/<!--.*?-->/s', '', $normalized);
+
+        // Normalisiere Whitespace
+        $normalized = preg_replace('/\s+/', ' ', $normalized);
+        $normalized = trim($normalized);
+
+        // Cache das normalisierte Template
+        $this->normalizedTemplates[$cacheKey] = $normalized;
+
+        return $normalized;
+    }
+
+    public function extractCacheableBlocks(string $template): array
+    {
+        $blocks = [];
+
+        // Finde data-cache Attribute für explizite Cache-Bereiche
+        if (preg_match_all('/<[^>]+data-cache="([^"]+)"[^>]*>(.*?)<\/[^>]+>/s', $template, $matches, PREG_SET_ORDER)) {
+            foreach ($matches as $match) {
+                $blocks[] = [
+                    'id' => $match[1],
+                    'content' => $match[2],
+                    'type' => 'explicit'
+                ];
+            }
+        }
+
+        // Finde wiederholende Strukturen (Listen, Cards etc.)
+        if (preg_match_all('/<(ul|ol|div class="[^"]*list[^"]*")[^>]*>(.*?)<\/\1>/s', $template, $matches, PREG_SET_ORDER)) {
+            foreach ($matches as $i => $match) {
+                $blocks[] = [
+                    'id' => 'list_block_' . $i,
+                    'content' => $match[2],
+                    'type' => 'list'
+                ];
+            }
+        }
+
+        return $blocks;
+    }
+
+    public function generateOptimizedCacheKey(RenderContext $context, array $dependencies = []): string
+    {
+        $keyParts = [
+            $context->template,
+            $context->controllerClass ?? 'default',
+        ];
+
+        // Füge nur relevante Daten hinzu (nicht alles aus $context->data)
+        $relevantData = $this->extractRelevantData($context->data, $dependencies);
+        if (!empty($relevantData)) {
+            $keyParts[] = md5(serialize($relevantData));
+        }
+
+        // Füge Template-Änderungszeit hinzu für Auto-Invalidation
+        $templatePath = $this->resolveTemplatePath($context->template);
+        if (file_exists($templatePath)) {
+            $keyParts[] = filemtime($templatePath);
+        }
+
+        return implode(':', $keyParts);
+    }
+
+    private function extractRelevantData(array $data, array $dependencies): array
+    {
+        if (empty($dependencies)) {
+            return $data;
+        }
+
+        $relevant = [];
+        foreach ($dependencies as $key) {
+            if (isset($data[$key])) {
+                $relevant[$key] = $data[$key];
+            }
+        }
+
+        return $relevant;
+    }
+
+    private function resolveTemplatePath(string $template): string
+    {
+        // Vereinfachte Template-Pfad-Auflösung
+        return "views/{$template}.php";
+    }
+}
diff --git a/.archive/Async1/DiscoveryFactory.php b/.archive/Async1/DiscoveryFactory.php
new file mode 100644
index 00000000..17d1385d
--- /dev/null
+++ b/.archive/Async1/DiscoveryFactory.php
@@ -0,0 +1,31 @@
+<?php
+declare(strict_types=1);
+
+namespace Archive\Async1;
+
+use App\Framework\Async1\AsyncDiscovery;
+use App\Framework\Async1\PcntlTaskProcessor;
+use App\Framework\Async1\TaskProcessorFactory;
+use App\Framework\Core\AttributeMapper;
+use App\Framework\Core\Discovery;
+
+final class DiscoveryFactory
+{
+    /**
+     * Erstellt eine Discovery-Instanz mit optionaler asynchroner Verarbeitung
+     *
+     * @param bool $useAsync Ob asynchrone Verarbeitung genutzt werden soll
+     * @param string|null $srcDir Quellverzeichnis für automatisches Auffinden von Mappern
+     * @param AttributeMapper ...$mappers AttributeMapper-Instanzen
+     * @return Discovery
+     */
+    public static function create(bool $useAsync = true, ?string $srcDir = null, AttributeMapper ...$mappers): Discovery
+    {
+        if ($useAsync && PcntlTaskProcessor::isAvailable()) {
+            return new AsyncDiscovery($srcDir, TaskProcessorFactory::create(), ...$mappers);
+        }
+
+        return new Discovery($srcDir, ...$mappers);
+    }
+
+}
diff --git a/.archive/Async1/ProcOpenTaskProcessor.php b/.archive/Async1/ProcOpenTaskProcessor.php
new file mode 100644
index 00000000..23aed350
--- /dev/null
+++ b/.archive/Async1/ProcOpenTaskProcessor.php
@@ -0,0 +1,166 @@
+<?php
+declare(strict_types=1);
+
+namespace Archive\Async1;
+
+use App\Framework\Async1\TaskProcessor;
+
+/**
+ * TaskProcessor-Implementierung für PCNTL mit Support für Closures
+ */
+final class ProcOpenTaskProcessor implements TaskProcessor
+{
+    private int $maxProcesses;
+    private string $tempDir;
+
+    public function __construct(int $maxProcesses = 4, ?string $tempDir = null)
+    {
+        $this->maxProcesses = $maxProcesses;
+        $this->tempDir = $tempDir ?? sys_get_temp_dir();
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function processTasks(array $tasks, mixed ...$sharedData): array
+    {
+        if (empty($tasks)) {
+            return [];
+        }
+
+        // Fasse gemeinsame Daten zusammen, die serialisierbar sind
+        $serializedSharedData = $this->safeSerialize($sharedData);
+        if ($serializedSharedData === false) {
+            throw new \RuntimeException("Gemeinsame Daten können nicht serialisiert werden");
+        }
+
+        // Teile die Aufgaben in Blöcke auf
+        $chunks = array_chunk($tasks, (int)ceil(count($tasks) / $this->maxProcesses));
+
+        $tempFiles = [];
+        $childPids = [];
+
+        // Starte für jeden Chunk einen separaten Prozess
+        foreach ($chunks as $index => $chunk) {
+            // Erstelle temporäre Datei für die Ergebnisse
+            $tempFile = $this->tempDir . '/async_results_' . uniqid() . '.tmp';
+            $tempFiles[$index] = $tempFile;
+
+            // Da wir Closures nicht serialisieren können, erstellen wir Stellvertreter-Aufgaben
+            $taskDescriptors = [];
+            foreach ($chunk as $taskIndex => $task) {
+                // Wir speichern nur den originalen Index für die spätere Zuordnung
+                $taskDescriptors[$taskIndex] = true;
+            }
+
+            // Starte einen Child-Prozess
+            $pid = pcntl_fork();
+
+            if ($pid == -1) {
+                throw new \RuntimeException('Konnte keinen neuen Prozess starten');
+            } elseif ($pid) {
+                // Elternprozess: speichere PID
+                $childPids[$pid] = ['index' => $index, 'chunk' => $chunk];
+            } else {
+                // Kindprozess: Verarbeite die Aufgaben
+                try {
+                    $chunkResults = [];
+
+                    // Deserialisiere gemeinsame Daten
+                    $decodedSharedData = unserialize($serializedSharedData);
+
+                    // Führe die Aufgaben in diesem Chunk aus
+                    foreach ($chunk as $taskIndex => $task) {
+                        try {
+                            // Führe die Task direkt aus, ohne zu serialisieren
+                            $chunkResults[$taskIndex] = $task(...$decodedSharedData);
+                        } catch (\Throwable $e) {
+                            // Fehler bei einer bestimmten Aufgabe
+                            $chunkResults[$taskIndex] = ['__error__' => $e->getMessage()];
+                        }
+                    }
+
+                    // Versuche, die Ergebnisse zu serialisieren
+                    $serializedResults = $this->safeSerialize($chunkResults);
+                    if ($serializedResults === false) {
+                        throw new \RuntimeException("Ergebnisse können nicht serialisiert werden");
+                    }
+
+                    // Speichere die Ergebnisse
+                    file_put_contents($tempFile, $serializedResults);
+                } catch (\Throwable $e) {
+                    // Schwerwiegender Fehler im Kindprozess
+                    file_put_contents($tempFile, serialize(['__process_error__' => $e->getMessage()]));
+                }
+
+                // Beende den Kindprozess
+                exit(0);
+            }
+        }
+
+        // Sammle die Ergebnisse aus allen Child-Prozessen
+        $allResults = [];
+
+        // Warte auf jeden Kindprozess
+        foreach ($childPids as $pid => $info) {
+            $index = $info['index'];
+            $chunk = $info['chunk'];
+
+            // Warte auf den Prozess
+            pcntl_waitpid($pid, $status);
+
+            $tempFile = $tempFiles[$index];
+
+            if (file_exists($tempFile)) {
+                $fileContent = file_get_contents($tempFile);
+
+                try {
+                    $chunkResults = unserialize($fileContent);
+
+                    if (is_array($chunkResults)) {
+                        if (isset($chunkResults['__process_error__'])) {
+                            error_log("Prozessfehler in Chunk $index: " . $chunkResults['__process_error__']);
+                        } else {
+                            // Füge die Ergebnisse zum Gesamtergebnis hinzu
+                            foreach ($chunkResults as $taskIndex => $result) {
+                                if (is_array($result) && isset($result['__error__'])) {
+                                    error_log("Fehler bei Task #$taskIndex: " . $result['__error__']);
+                                    $allResults[$taskIndex] = null;
+                                } else {
+                                    $allResults[$taskIndex] = $result;
+                                }
+                            }
+                        }
+                    }
+                } catch (\Throwable $e) {
+                    error_log("Fehler beim Deserialisieren der Ergebnisse aus Chunk $index: " . $e->getMessage());
+                }
+
+                // Lösche die temporäre Datei
+                unlink($tempFile);
+            }
+        }
+
+        return $allResults;
+    }
+
+    /**
+     * Sichere Serialisierung mit Fehlerbehandlung
+     */
+    private function safeSerialize($data)
+    {
+        try {
+            return serialize($data);
+        } catch (\Throwable $e) {
+            return false;
+        }
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public static function isAvailable(): bool
+    {
+        return function_exists('pcntl_fork') && function_exists('pcntl_waitpid');
+    }
+}
diff --git a/.archive/Async1/SynchronousTaskProcessor.php b/.archive/Async1/SynchronousTaskProcessor.php
new file mode 100644
index 00000000..7ab799c4
--- /dev/null
+++ b/.archive/Async1/SynchronousTaskProcessor.php
@@ -0,0 +1,36 @@
+<?php
+declare(strict_types=1);
+
+namespace Archive\Async1;
+
+use App\Framework\Async1\TaskProcessor;
+
+final class SynchronousTaskProcessor implements TaskProcessor
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function processTasks(array $tasks, mixed ...$sharedData): array
+    {
+        $results = [];
+
+        foreach ($tasks as $index => $task) {
+            try {
+                $results[$index] = $task(...$sharedData);
+            } catch (\Throwable $e) {
+                error_log("Fehler bei Task #{$index}: " . $e->getMessage());
+                $results[$index] = null;
+            }
+        }
+
+        return $results;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public static function isAvailable(): bool
+    {
+        return true; // Immer verfügbar
+    }
+}
diff --git a/.archive/Config/ApiConfig.php b/.archive/Config/ApiConfig.php
new file mode 100644
index 00000000..8382d3eb
--- /dev/null
+++ b/.archive/Config/ApiConfig.php
@@ -0,0 +1,25 @@
+<?php
+declare(strict_types=1);
+
+namespace Archive\Config;
+
+enum ApiConfig: string
+{
+    // RapidMail Konfiguration
+    case RAPIDMAIL_USERNAME = '3f60a5c15c3d49c631d0e75b7c1090a3859423a7';
+    case RAPIDMAIL_PASSWORD = '572d25dc36e620f14c89e9c75c02c1f3794ba3c0';
+    case RAPIDMAIL_DEFAULT_LIST_ID = '776';
+
+    // Shopify API Konfiguration
+    case SHOPIFY_SHOP_DOMAIN = 'michaelschiemer.myshopify.com';
+    case SHOPIFY_ACCESS_TOKEN = 'shpat_123456789abcdef';
+    case SHOPIFY_API_VERSION = '2024-04';
+
+    /**
+     * Gibt die numerische RapidMail-Listen-ID zurück
+     */
+    public static function getRapidmailListId(): int
+    {
+        return (int)self::RAPIDMAIL_DEFAULT_LIST_ID->value;
+    }
+}
diff --git a/.archive/Config/analytics.php b/.archive/Config/analytics.php
new file mode 100644
index 00000000..87f9716e
--- /dev/null
+++ b/.archive/Config/analytics.php
@@ -0,0 +1,33 @@
+<?php
+
+return [
+    // Aktiviert oder deaktiviert das Analytics-Modul
+    'enabled' => true,
+
+    // Automatisches Speichern nach Erreichen der Batch-Größe
+    'auto_flush' => true,
+
+    // Anzahl der Events, die gesammelt werden, bevor sie gespeichert werden
+    'batch_size' => 50,
+
+    // Storage-Backend ('file')
+    'storage' => 'file',
+
+    // Speicherpfad für Analytics-Daten (relativ zum Datenverzeichnis)
+    'storage_path' => __DIR__ . '/../data/analytics',
+
+    // Anonymisierung von persönlichen Daten
+    'anonymize_ip' => true,
+
+    // Benutzerdefinierte Events, die getrackt werden sollen
+    'track_events' => [
+        'page_view',
+        'error',
+        'performance',
+        'database',
+        'http_request',
+        'http_response',
+        'user_login',
+        'user_logout',
+    ],
+];
diff --git a/.archive/Media/Controllers/MediaController.php b/.archive/Media/Controllers/MediaController.php
new file mode 100644
index 00000000..172682a6
--- /dev/null
+++ b/.archive/Media/Controllers/MediaController.php
@@ -0,0 +1,82 @@
+<?php
+
+namespace Media\Controllers;
+
+use App\Framework\Attributes\Route;
+use App\Framework\Core\PathProvider;
+use App\Framework\Http\Headers;
+use App\Framework\Http\HttpResponse;
+use App\Framework\Http\Method;
+use App\Framework\Http\Status;
+use App\Framework\Router\Result\FileResult;
+use Media\Entities\Image;
+use Media\Services\ImageService;
+
+class MediaController
+{
+    public function __construct(
+        private ImageService $imageService,
+        private PathProvider $pathProvider,
+    ) {}
+
+    #[Route('/media/{path}-{filename}', method: Method::GET)]
+    public function serveMedia(string $path, string $filename): FileResult
+    {
+        $image = $this->imageService->resolveFromUrlId($path);
+
+        $imagePath = $this->pathProvider->resolvePath('storage' . $image->uploadPath . '/' . $filename);
+
+        #debug($imagePath);
+
+        // Prüfen ob Datei existiert
+        if (!file_exists($imagePath)) {
+            die('oh');
+            return $this->notFound();
+        }
+
+        // Lese Datei und sende sie zurück
+        $content = file_get_contents($imagePath);
+        $mimeType = $this->getMimeTypeFromFormat($image->mimeType);
+
+        $headers = new Headers([
+            'Content-Type' => $mimeType,
+            'Content-Length' => filesize($imagePath),
+            'Cache-Control' => 'public, max-age=31536000', // 1 Jahr cachen
+            'ETag' => '"' . md5_file($imagePath) . '"',
+        ]);
+
+        return new FileResult($imagePath);
+
+        return new HttpResponse(
+            Status::OK,
+            $headers,
+            $content
+        );
+    }
+
+    private function constructImagePath(Image $image, string $variant, string $format): string
+    {
+        return $this->pathProvider->resolvePath('storage' . $image->uploadPath . '/' . $variant . '.' . $format);
+    }
+
+    private function getMimeTypeFromFormat(string $format): string
+    {
+        return match ($format) {
+            'jpg' => 'image/jpeg',
+            'png' => 'image/png',
+            'gif' => 'image/gif',
+            'webp' => 'image/webp',
+            'avif' => 'image/avif',
+            default => 'application/octet-stream'
+        };
+    }
+
+    private function notFound(): HttpResponse
+    {
+        return new HttpResponse(
+            Status::NOT_FOUND,
+            new Headers(['Content-Type' => 'text/plain']),
+            'Bild nicht gefunden'
+        );
+    }
+}
diff --git a/.archive/Media/Entities/Image.php b/.archive/Media/Entities/Image.php
new file mode 100644
index 00000000..d1a01fc2
--- /dev/null
+++ b/.archive/Media/Entities/Image.php
@@ -0,0 +1,57 @@
+<?php
+
+namespace Media\Entities;
+
+use App\Framework\Database\Attributes\Entity;
+
+#[Entity(tableName: 'images')]
+class Image
+{
+    public function __construct(
+        public ?int $id = null,
+        public string $filename = '',
+        public string $originalFilename = '',
+        public string $mimeType = '',
+        public int $fileSize = 0,
+        public int $width = 0,
+        public int $height = 0,
+        public string $hash = '',
+        public string $uploadPath = '',
+        public \DateTimeImmutable $createdAt = new \DateTimeImmutable(),
+        public ?\DateTimeImmutable $updatedAt = null,
+    ) {}
+
+    public function getUploadDirectory(): string
+    {
+        return sprintf(
+            '/uploads/%s/%s/%s',
+            $this->createdAt->format('Y'),
+            $this->createdAt->format('m'),
+            $this->createdAt->format('d')
+        );
+    }
+
+    public function getFilePathPattern(): string
+    {
+        $idStr = str_pad((string)$this->id, 9, '0', STR_PAD_LEFT);
+        return sprintf(
+            '%s/%s/%s/%s',
+            substr($idStr, 0, 3),
+            substr($idStr, 3, 3),
+            substr($idStr, 6, 3),
+            $idStr
+        );
+    }
+
+    /**
+     * Generiert eine eindeutige URL-freundliche ID ohne Slashes
+     */
+    public function getUrlId(): string
+    {
+        // Kombiniert Datum und ID zu einem eindeutigen String
+        $dateStr = $this->createdAt->format('Ymd');
+        $idStr = str_pad((string)$this->id, 8, '0', STR_PAD_LEFT);
+        return $dateStr . $idStr;
+    }
+
+}
diff --git a/.archive/Media/Entities/ImageVariant.php b/.archive/Media/Entities/ImageVariant.php
new file mode 100644
index 00000000..5f370432
--- /dev/null
+++ b/.archive/Media/Entities/ImageVariant.php
@@ -0,0 +1,32 @@
+<?php
+
+namespace Media\Entities;
+
+use App\Framework\Database\Attributes\Entity;
+
+#[Entity(tableName: 'image_variants')]
+class ImageVariant
+{
+    public function __construct(
+        public ?int $id = null,
+        public int $imageId = 0,
+        public string $variant = '', // 'thumbnail', 'small', 'medium', 'large'
+        public string $format = '', // 'jpg', 'webp', 'avif'
+        public int $width = 0,
+        public int $height = 0,
+        public int $fileSize = 0,
+        public string $filename = '',
+        public \DateTimeImmutable $createdAt = new \DateTimeImmutable(),
+    ) {}
+
+    public function getFullPath(Image $image): string
+    {
+        return sprintf(
+            '%s/%s/%s.%s',
+            $image->getUploadDirectory(),
+            $image->getFilePathPattern(),
+            $this->variant,
+            $this->format
+        );
+    }
+}
diff --git a/.archive/Media/Repositories/ImageRepository.php b/.archive/Media/Repositories/ImageRepository.php
new file mode 100644
index 00000000..2537f43b
--- /dev/null
+++ b/.archive/Media/Repositories/ImageRepository.php
@@ -0,0 +1,106 @@
+<?php
+
+namespace Media\Repositories;
+
+use App\Framework\Database\Connection;
+use App\Framework\Database\ConnectionInterface;
+use Media\Entities\Image;
+
+class ImageRepository
+{
+    public function __construct(
+        private ConnectionInterface $db
+    ) {
+
+    }
+
+    public function save(Image $image): Image
+    {
+        $query = "INSERT INTO images "
+             . "(filename, original_filename, mime_type, file_size, width, height, hash, upload_path, created_at) "
+             . "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?);";
+
+        $this->db->execute(
+            $query,
+            [
+                $image->filename,
+                $image->originalFilename,
+                $image->mimeType,
+                $image->fileSize,
+                $image->width,
+                $image->height,
+                $image->hash,
+                $image->uploadPath,
+                $image->createdAt->format('Y-m-d H:i:s'),
+            ]
+        );
+
+        $image->id = (int)$this->db->lastInsertId();
+
+        return $image;
+    }
+
+    public function update(Image $image): void
+    {
+        $query = "UPDATE images SET "
+             . "filename = ?, original_filename = ?, mime_type = ?, file_size = ?, "
+             . "width = ?, height = ?, hash = ?, upload_path = ?, updated_at = CURRENT_TIMESTAMP "
+             . "WHERE id = ?;";
+
+        $this->db->execute(
+            $query,
+            [
+                $image->filename,
+                $image->originalFilename,
+                $image->mimeType,
+                $image->fileSize,
+                $image->width,
+                $image->height,
+                $image->hash,
+                $image->uploadPath,
+                $image->id,
+            ]
+        );
+    }
+
+    public function findById(int $id): ?Image
+    {
+        $query = "SELECT * FROM images WHERE id = ?;";
+        $result = $this->db->query($query, [$id])->fetch();
+
+        if (null === $result) {
+            return null;
+        }
+
+        return $this->mapToEntity($result);
+    }
+
+    public function findByHash(string $hash): ?Image
+    {
+        $query = "SELECT * FROM images WHERE hash = ?;";
+        $result = $this->db->query($query, [$hash])->fetch();
+
+        if (!$result) {
+            return null;
+        }
+
+        return $this->mapToEntity($result);
+    }
+
+    private function mapToEntity(array $data): Image
+    {
+        return new Image(
+            id: (int)$data['id'],
+            filename: $data['filename'],
+            originalFilename: $data['original_filename'],
+            mimeType: $data['mime_type'],
+            fileSize: (int)$data['file_size'],
+            width: (int)$data['width'],
+            height: (int)$data['height'],
+            hash: $data['hash'],
+            uploadPath: $data['upload_path'],
+            createdAt: new \DateTimeImmutable($data['created_at']),
+            updatedAt: $data['updated_at'] ? new \DateTimeImmutable($data['updated_at']) : null,
+        );
+    }
+}
diff --git a/.archive/Media/Repositories/ImageVariantRepository.php b/.archive/Media/Repositories/ImageVariantRepository.php
new file mode 100644
index 00000000..cf52ac5d
--- /dev/null
+++ b/.archive/Media/Repositories/ImageVariantRepository.php
@@ -0,0 +1,74 @@
+<?php
+
+namespace Media\Repositories;
+
+use App\Framework\Database\Connection;
+use App\Framework\Database\ConnectionInterface;
+use Media\Entities\ImageVariant;
+
+class ImageVariantRepository
+{
+    public function __construct(
+        private ConnectionInterface $db
+    ) {}
+
+    public function save(ImageVariant $variant): ImageVariant
+    {
+        $query = "INSERT INTO image_variants "
+             . "(image_id, variant, format, width, height, file_size, filename, created_at) "
+             . "VALUES (?, ?, ?, ?, ?, ?, ?, ?)";
+
+        $this->db->execute(
+            $query,
+            [
+                $variant->imageId,
+                $variant->variant,
+                $variant->format,
+                $variant->width,
+                $variant->height,
+                $variant->fileSize,
+                $variant->filename,
+                $variant->createdAt->format('Y-m-d H:i:s'),
+            ]
+        );
+
+        $variant->id = (int)$this->db->lastInsertId();
+
+        return $variant;
+    }
+
+    public function findByImageId(int $imageId): array
+    {
+        $query = "SELECT * FROM image_variants WHERE image_id = ?;";
+        $results = $this->db->query($query, [$imageId]);
+
+        return array_map(fn($data) => $this->mapToEntity($data), $results);
+    }
+
+    public function findByImageIdAndVariant(int $imageId, string $variant, string $format): ?ImageVariant
+    {
+        $query = "SELECT * FROM image_variants WHERE image_id = ? AND variant = ? AND format = ?;";
+        $result = $this->db->query($query, [$imageId, $variant, $format]);
+
+        if (empty($result)) {
+            return null;
+        }
+
+        return $this->mapToEntity($result[0]);
+    }
+
+    private function mapToEntity(array $data): ImageVariant
+    {
+        return new ImageVariant(
+            id: (int)$data['id'],
+            imageId: (int)$data['image_id'],
+            variant: $data['variant'],
+            format: $data['format'],
+            width: (int)$data['width'],
+            height: (int)$data['height'],
+            fileSize: (int)$data['file_size'],
+            filename: $data['filename'],
+            createdAt: new \DateTimeImmutable($data['created_at']),
+        );
+    }
+}
diff --git a/.archive/Media/Services/ImageService.php b/.archive/Media/Services/ImageService.php
new file mode 100644
index 00000000..67d385e8
--- /dev/null
+++ b/.archive/Media/Services/ImageService.php
@@ -0,0 +1,265 @@
+<?php
+
+namespace Media\Services;
+
+use App\Framework\Core\PathProvider;
+use App\Framework\Http\UploadedFile;
+use Media\Entities\Image;
+use Media\Entities\ImageVariant;
+use Media\Repositories\ImageRepository;
+use Media\Repositories\ImageVariantRepository;
+use function filesize;
+use function getimagesize;
+use function imageavif;
+use function imagecopyresampled;
+use function imagecreatefromstring;
+use function imagecreatetruecolor;
+use function imagedestroy;
+use function imagejpeg;
+use function imagesx;
+use function imagesy;
+use function imagewebp;
+
+class ImageService
+{
+    private const array VARIANTS = [
+        'thumbnail' => ['width' => 150, 'height' => 150, 'crop' => true],
+        'small' => ['width' => 400, 'height' => 400, 'crop' => false],
+        'medium' => ['width' => 800, 'height' => 800, 'crop' => false],
+        'large' => ['width' => 1200, 'height' => 1200, 'crop' => false],
+    ];
+
+    private const array FORMATS = ['jpg', 'webp', 'avif'];
+
+    public function __construct(
+        private PathProvider $pathProvider,
+        private ImageRepository $imageRepository,
+        private ImageVariantRepository $variantRepository,
+    ) {}
+
+    public function uploadImage(UploadedFile $file): Image
+    {
+        // Validierung
+        if (!$file->isValid()) {
+            throw new \InvalidArgumentException('Ungültige Datei');
+        }
+
+        if (!$this->isValidImageType($file->getMimeType())) {
+            throw new \InvalidArgumentException('Ungültiger Bildtyp');
+        }
+
+        // Basis-Image-Informationen erfassen
+        $imageInfo = getimagesize($file->tmpName);
+        $hash = \hash_file('sha256', $file->tmpName);
+
+        // Prüfen ob ein Bild mit gleichem Hash bereits existiert
+        $existingImage = $this->imageRepository->findByHash($hash);
+        if ($existingImage) {
+            return $existingImage; // Duplikat gefunden, vorhandenes Bild zurückgeben
+        }
+
+        // Image Entity erstellen
+        $image = new Image(
+            filename: $this->generateSecureFilename($file->name),
+            originalFilename: $file->name,
+            mimeType: $file->getMimeType(),
+            fileSize: $file->size,
+            width: $imageInfo[0],
+            height: $imageInfo[1],
+            hash: $hash,
+            uploadPath: '',
+        );
+
+        // In Datenbank speichern um ID zu erhalten
+        $image = $this->imageRepository->save($image);
+
+        // Upload-Pfad setzen
+        $image->uploadPath = $image->getUploadDirectory() . '/' . $image->getFilePathPattern();
+
+        $this->imageRepository->update($image);
+
+        // Ordnerstruktur erstellen
+        $fullUploadPath = $this->pathProvider->resolvePath('storage' . $image->uploadPath);
+        $this->createDirectoryStructure($fullUploadPath);
+
+        // Original-Datei speichern
+        $originalPath = $fullUploadPath . '/original.' . $this->getFileExtension($file->getMimeType());
+        $file->moveTo($originalPath);
+
+        // Varianten erstellen
+        $this->createImageVariants($image, $originalPath);
+
+        // Image in Datenbank aktualisieren
+        #$this->imageRepository->update($image);
+
+        return $image;
+    }
+
+    private function createImageVariants(Image $image, string $originalPath): void
+    {
+        foreach (self::VARIANTS as $variantName => $config) {
+            foreach (self::FORMATS as $format) {
+                $variant = $this->createImageVariant(
+                    $image,
+                    $originalPath,
+                    $variantName,
+                    $format,
+                    $config
+                );
+
+                // In Datenbank speichern
+                $this->variantRepository->save($variant);
+            }
+        }
+    }
+
+    private function createImageVariant(
+        Image $image,
+        string $originalPath,
+        string $variantName,
+        string $format,
+        array $config
+    ): ImageVariant {
+        $outputPath = $this->pathProvider->resolvePath('storage' . $image->uploadPath . '/' . $variantName . '.' . $format);
+
+        // Bild verarbeiten
+        $resizedImage = $this->resizeImage($originalPath, $config['width'], $config['height'], $config['crop'] ?? false);
+        $this->saveImageInFormat($resizedImage, $outputPath, $format);
+
+        // Neue Dateigröße und Dimensionen ermitteln
+        $newImageInfo = getimagesize($outputPath);
+        $fileSize = filesize($outputPath);
+
+        return new ImageVariant(
+            imageId: $image->id,
+            variant: $variantName,
+            format: $format,
+            width: $newImageInfo[0],
+            height: $newImageInfo[1],
+            fileSize: $fileSize,
+            filename: $variantName . '.' . $format
+        );
+    }
+
+    private function resizeImage(string $sourcePath, int $maxWidth, int $maxHeight, bool $crop = false): \GdImage
+    {
+        $sourceImage = imagecreatefromstring(\file_get_contents($sourcePath));
+        $sourceWidth = imagesx($sourceImage);
+        $sourceHeight = imagesy($sourceImage);
+
+        if ($crop) {
+            // Crop-Logik für quadratische Thumbnails
+            $ratio = max($maxWidth / $sourceWidth, $maxHeight / $sourceHeight);
+            $newWidth = (int)round($sourceWidth * $ratio);
+            $newHeight = (int)round($sourceHeight * $ratio);
+
+            $tempImage = imagecreatetruecolor($newWidth, $newHeight);
+            imagecopyresampled($tempImage, $sourceImage, 0, 0, 0, 0, $newWidth, $newHeight, $sourceWidth, $sourceHeight);
+
+            $finalImage = imagecreatetruecolor($maxWidth, $maxHeight);
+            $cropX = (int)floor(($newWidth - $maxWidth) / 2);
+            $cropY = (int)floor(($newHeight - $maxHeight) / 2);
+            \imagecopy($finalImage, $tempImage, 0, 0, $cropX, $cropY, $maxWidth, $maxHeight);
+
+            imagedestroy($tempImage);
+        } else {
+            // Proportionales Skalieren
+            $ratio = min($maxWidth / $sourceWidth, $maxHeight / $sourceHeight);
+            $newWidth = (int)round($sourceWidth * $ratio);
+            $newHeight = (int)round($sourceHeight * $ratio);
+
+            $finalImage = imagecreatetruecolor($newWidth, $newHeight);
+            imagecopyresampled($finalImage, $sourceImage, 0, 0, 0, 0, $newWidth, $newHeight, $sourceWidth, $sourceHeight);
+        }
+
+        imagedestroy($sourceImage);
+        return $finalImage;
+    }
+
+    private function saveImageInFormat(\GdImage $image, string $path, string $format): void
+    {
+        switch ($format) {
+            case 'jpg':
+                imagejpeg($image, $path, 85);
+                break;
+            case 'webp':
+                imagewebp($image, $path, 85);
+                break;
+            case 'avif':
+                if (\function_exists('imageavif')) {
+                    imageavif($image, $path, 85);
+                } else {
+                    // Fallback auf WebP wenn AVIF nicht verfügbar
+                    imagewebp($image, $path, 85);
+                }
+                break;
+        }
+        imagedestroy($image);
+    }
+
+    private function createDirectoryStructure(string $path): void
+    {
+        if (!is_dir($path)) {
+            mkdir($path, 0755, true);
+        }
+    }
+
+    private function isValidImageType(string $mimeType): bool
+    {
+        return in_array($mimeType, [
+            'image/jpeg',
+            'image/png',
+            'image/gif',
+            'image/webp'
+        ]);
+    }
+
+    private function getFileExtension(string $mimeType): string
+    {
+        return match ($mimeType) {
+            'image/jpeg' => 'jpg',
+            'image/png' => 'png',
+            'image/gif' => 'gif',
+            'image/webp' => 'webp',
+            default => 'jpg'
+        };
+    }
+
+    private function generateSecureFilename(string $originalName): string
+    {
+        $extension = pathinfo($originalName, PATHINFO_EXTENSION);
+        return uniqid('img_', true) . '.' . strtolower($extension);
+    }
+
+    public function getImageUrl(Image $image, string $variant = 'medium', string $format = 'jpg'): string
+    {
+        return '/media/' . $image->getUrlId() . '-' . $variant . '.' . $format;
+    }
+
+    public function findById(int $id): ?Image
+    {
+        return $this->imageRepository->findById($id);
+    }
+
+    public function getVariants(Image $image): array
+    {
+        return $this->variantRepository->findByImageId($image->id);
+    }
+
+    /**
+     * Löst eine URL-ID zu einem Image-Objekt auf
+     */
+    public function resolveFromUrlId(string $urlId): ?Image
+    {
+        // URL-ID format: YYYYMMDDXXXXXXXX (Datum + 8-stellige ID)
+        if (strlen($urlId) !== 16) {
+            return null;
+        }
+
+        $idPart = substr($urlId, 8); // Die letzten 8 Zeichen
+        $id = (int)ltrim($idPart, '0'); // Führende Nullen entfernen
+
+        return $this->imageRepository->findById($id);
+    }
+
+}
diff --git a/.archive/Optimized/CacheAnalysis.php b/.archive/Optimized/CacheAnalysis.php
new file mode 100644
index 00000000..974419b1
--- /dev/null
+++ b/.archive/Optimized/CacheAnalysis.php
@@ -0,0 +1,30 @@
+<?php
+
+namespace Archive\Optimized;
+
+/**
+ * Cache-Analyse für Template-Rendering
+ */
+final readonly class CacheAnalysis
+{
+    public function __construct(
+        public CacheStrategy $strategy,
+        public int $ttl,
+        public array $dependencies = [],
+    ) {}
+
+    public function shouldCache(): bool
+    {
+        return $this->strategy !== CacheStrategy::DYNAMIC && $this->ttl > 0;
+    }
+
+    public function isUserSpecific(): bool
+    {
+        return isset($this->dependencies['user_id']) || isset($this->dependencies['session_id']);
+    }
+
+    public function getComplexity(): int
+    {
+        return count($this->dependencies) + ($this->isUserSpecific() ? 5 : 0);
+    }
+}
diff --git a/.archive/Optimized/CacheStrategy.php b/.archive/Optimized/CacheStrategy.php
new file mode 100644
index 00000000..3777bb4a
--- /dev/null
+++ b/.archive/Optimized/CacheStrategy.php
@@ -0,0 +1,49 @@
+<?php
+
+namespace Archive\Optimized;
+
+/**
+ * Cache-Strategien für Templates
+ */
+enum CacheStrategy: string
+{
+    case STATIC = 'static';      // Vollständig statischer Content
+    case PARTIAL = 'partial';    // Teilweise dynamischer Content
+    case FRAGMENT = 'fragment';  // Fragment-basiertes Caching
+    case DYNAMIC = 'dynamic';    // Kein Caching (vollständig dynamisch)
+
+    public function getTtl(): int
+    {
+        return match($this) {
+            self::STATIC => 3600,    // 1 Stunde
+            self::PARTIAL => 900,    // 15 Minuten
+            self::FRAGMENT => 600,   // 10 Minuten
+            self::DYNAMIC => 0,      // Kein Caching
+        };
+    }
+
+    public function getPriority(): int
+    {
+        return match($this) {
+            self::STATIC => 1,       // Höchste Priorität
+            self::PARTIAL => 2,
+            self::FRAGMENT => 3,
+            self::DYNAMIC => 4,      // Niedrigste Priorität
+        };
+    }
+
+    public function shouldCache(): bool
+    {
+        return $this !== self::DYNAMIC;
+    }
+
+    public function getDescription(): string
+    {
+        return match($this) {
+            self::STATIC => 'Fully cacheable static content',
+            self::PARTIAL => 'Partially cacheable with some dynamic elements',
+            self::FRAGMENT => 'Fragment-based caching for mixed content',
+            self::DYNAMIC => 'Fully dynamic content, no caching',
+        };
+    }
+}
diff --git a/.archive/Optimized/TemplateAnalysis.php b/.archive/Optimized/TemplateAnalysis.php
new file mode 100644
index 00000000..d66bf86e
--- /dev/null
+++ b/.archive/Optimized/TemplateAnalysis.php
@@ -0,0 +1,30 @@
+<?php
+
+namespace Archive\Optimized;
+
+/**
+ * Template-Analyse-Ergebnisse
+ */
+final class TemplateAnalysis
+{
+    public array $staticBlocks = [];
+    public array $dynamicBlocks = [];
+    public array $dependencies = [];
+    public array $optimizations = [];
+    public CacheStrategy $cacheStrategy = CacheStrategy::DYNAMIC;
+
+    public function getComplexity(): int
+    {
+        return count($this->staticBlocks) + count($this->dynamicBlocks) * 2;
+    }
+
+    public function isCacheable(): bool
+    {
+        return $this->cacheStrategy !== CacheStrategy::DYNAMIC;
+    }
+
+    public function hasFragments(): bool
+    {
+        return count($this->staticBlocks) > 0;
+    }
+}
diff --git a/.archive/StreamWrapper/Context/StreamContext.php b/.archive/StreamWrapper/Context/StreamContext.php
new file mode 100644
index 00000000..eb14d437
--- /dev/null
+++ b/.archive/StreamWrapper/Context/StreamContext.php
@@ -0,0 +1,87 @@
+<?php
+declare(strict_types=1);
+
+namespace Archive\StreamWrapper\Context;
+
+/**
+ * Wrapper für Stream-Context-Optionen
+ */
+final class StreamContext
+{
+    private array $options = [];
+    private array $params = [];
+
+    public function __construct($resource = null)
+    {
+        if ($resource !== null) {
+            $this->options = stream_context_get_options($resource);
+            $this->params = stream_context_get_params($resource);
+        }
+    }
+
+    /**
+     * Gibt eine Option für das angegebene Protokoll zurück
+     */
+    public function getOption(string $protocol, string $key, $default = null)
+    {
+        return $this->options[$protocol][$key] ?? $default;
+    }
+
+    /**
+     * Gibt alle Optionen für ein Protokoll zurück
+     */
+    public function getProtocolOptions(string $protocol): array
+    {
+        return $this->options[$protocol] ?? [];
+    }
+
+    /**
+     * Setzt eine Option für das angegebene Protokoll
+     */
+    public function setOption(string $protocol, string $key, $value): self
+    {
+        $this->options[$protocol][$key] = $value;
+        return $this;
+    }
+
+    /**
+     * Gibt einen Parameter zurück
+     */
+    public function getParam(string $key, $default = null)
+    {
+        return $this->params[$key] ?? $default;
+    }
+
+    /**
+     * Setzt einen Parameter
+     */
+    public function setParam(string $key, $value): self
+    {
+        $this->params[$key] = $value;
+        return $this;
+    }
+
+    /**
+     * Gibt alle Optionen zurück
+     */
+    public function getAllOptions(): array
+    {
+        return $this->options;
+    }
+
+    /**
+     * Gibt alle Parameter zurück
+     */
+    public function getAllParams(): array
+    {
+        return $this->params;
+    }
+
+    /**
+     * Erstellt einen neuen Stream-Context mit den aktuellen Optionen
+     */
+    public function createResource()
+    {
+        return stream_context_create($this->options, $this->params);
+    }
+}
diff --git a/.archive/StreamWrapper/Exception/UnsupportedProtocolException.php b/.archive/StreamWrapper/Exception/UnsupportedProtocolException.php
new file mode 100644
index 00000000..381ff33d
--- /dev/null
+++ b/.archive/StreamWrapper/Exception/UnsupportedProtocolException.php
@@ -0,0 +1,17 @@
+<?php
+declare(strict_types=1);
+
+namespace Archive\StreamWrapper\Exception;
+
+use App\Framework\StreamWrapper\Exception\StreamWrapperException;
+
+/**
+ * Exception für nicht unterstützte Stream-Protokolle
+ */
+class UnsupportedProtocolException extends StreamWrapperException
+{
+    public function __construct(string $protocol)
+    {
+        parent::__construct("Unsupported stream protocol: $protocol");
+    }
+}
diff --git a/.archive/StreamWrapper/Filter/Filters/AES256DecryptFilter.php b/.archive/StreamWrapper/Filter/Filters/AES256DecryptFilter.php
new file mode 100644
index 00000000..fa10fdc9
--- /dev/null
+++ b/.archive/StreamWrapper/Filter/Filters/AES256DecryptFilter.php
@@ -0,0 +1,104 @@
+<?php
+declare(strict_types=1);
+
+namespace Archive\StreamWrapper\Filter\Filters;
+
+use Archive\StreamWrapper\Filter\StreamFilterInterface;
+
+/**
+ * Stream-Filter für AES-256-Entschlüsselung
+ */
+class AES256DecryptFilter extends \php_user_filter implements StreamFilterInterface
+{
+    private string $filterName = 'decrypt.aes256';
+    private array $supportedModes = ['read'];
+    private array $params = [];
+
+    private string $key = '';
+    private string $method = 'AES-256-CBC';
+
+    public function onCreate(): bool
+    {
+        // Parameter aus dem Stream-Context extrahieren
+        if (isset($this->params)) {
+            $this->params = $this->params;
+        }
+
+        $this->key = $this->getParam('key', '');
+        $this->method = $this->getParam('method', 'AES-256-CBC');
+
+        return !empty($this->key);
+    }
+
+    public function onClose(): void
+    {
+        // Cleanup falls nötig
+    }
+
+    public function getFilterName(): string
+    {
+        return $this->filterName;
+    }
+
+    public function getSupportedModes(): array
+    {
+        return $this->supportedModes;
+    }
+
+    public function filter($in, $out, &$consumed, bool $closing): int
+    {
+        $data = $this->readFromBrigade($in);
+        $consumed = strlen($data);
+
+        if (!empty($data)) {
+            $ivLength = openssl_cipher_iv_length($this->method);
+
+            if (strlen($data) < $ivLength) {
+                return PSFS_ERR_FATAL;
+            }
+
+            $iv = substr($data, 0, $ivLength);
+            $encrypted = substr($data, $ivLength);
+
+            $decrypted = openssl_decrypt($encrypted, $this->method, $this->key, OPENSSL_RAW_DATA, $iv);
+            if ($decrypted === false) {
+                return PSFS_ERR_FATAL;
+            }
+
+            $this->writeToBrigade($out, $decrypted);
+        }
+
+        return PSFS_PASS_ON;
+    }
+
+    /**
+     * Hilfsmethode zum Lesen von Daten aus der Input-Brigade
+     */
+    private function readFromBrigade($brigade): string
+    {
+        $data = '';
+        while ($bucket = stream_bucket_make_writeable($brigade)) {
+            $data .= $bucket->data;
+        }
+        return $data;
+    }
+
+    /**
+     * Hilfsmethode zum Schreiben von Daten in die Output-Brigade
+     */
+    private function writeToBrigade($brigade, string $data): void
+    {
+        if (!empty($data)) {
+            $bucket = stream_bucket_new($this->stream, $data);
+            stream_bucket_append($brigade, $bucket);
+        }
+    }
+
+    /**
+     * Gibt einen Parameter zurück
+     */
+    private function getParam(string $key, $default = null)
+    {
+        return $this->params[$key] ?? $default;
+    }
+}
diff --git a/.archive/StreamWrapper/Filter/Filters/AccessLogFilter.php b/.archive/StreamWrapper/Filter/Filters/AccessLogFilter.php
new file mode 100644
index 00000000..ec22050e
--- /dev/null
+++ b/.archive/StreamWrapper/Filter/Filters/AccessLogFilter.php
@@ -0,0 +1,107 @@
+<?php
+declare(strict_types=1);
+
+namespace Archive\StreamWrapper\Filter\Filters;
+
+use Archive\StreamWrapper\Filter\StreamFilterInterface;
+
+/**
+ * Stream-Filter für Access-Logging
+ */
+class AccessLogFilter extends \php_user_filter implements StreamFilterInterface
+{
+    private string $filterName = 'log.access';
+    private array $supportedModes = ['read', 'write'];
+    private array $params = [];
+
+    private string $logFile = '';
+    private bool $logReadAccess = true;
+    private bool $logWriteAccess = true;
+
+    public function onCreate(): bool
+    {
+        // Parameter aus dem Stream-Context extrahieren
+        if (isset($this->params)) {
+            $this->params = $this->params;
+        }
+
+        $this->logFile = $this->getParam('log_file', sys_get_temp_dir() . '/stream_access.log');
+        $this->logReadAccess = $this->getParam('log_read', true);
+        $this->logWriteAccess = $this->getParam('log_write', true);
+
+        return true;
+    }
+
+    public function onClose(): void
+    {
+        // Cleanup falls nötig
+    }
+
+    public function getFilterName(): string
+    {
+        return $this->filterName;
+    }
+
+    public function getSupportedModes(): array
+    {
+        return $this->supportedModes;
+    }
+
+    public function filter($in, $out, &$consumed, bool $closing): int
+    {
+        $data = $this->readFromBrigade($in);
+        $consumed = strlen($data);
+
+        if (!empty($data)) {
+            // Access-Log schreiben
+            $this->logAccess($data);
+
+            // Daten unverändert durchreichen
+            $this->writeToBrigade($out, $data);
+        }
+
+        return PSFS_PASS_ON;
+    }
+
+    private function logAccess(string $data): void
+    {
+        $timestamp = date('Y-m-d H:i:s');
+        $size = strlen($data);
+        $mode = $this->filtername; // read oder write
+
+        $logEntry = "[{$timestamp}] {$mode} - {$size} bytes\n";
+
+        file_put_contents($this->logFile, $logEntry, FILE_APPEND | LOCK_EX);
+    }
+
+    /**
+     * Hilfsmethode zum Lesen von Daten aus der Input-Brigade
+     */
+    private function readFromBrigade($brigade): string
+    {
+        $data = '';
+        while ($bucket = stream_bucket_make_writeable($brigade)) {
+            $data .= $bucket->data;
+        }
+        return $data;
+    }
+
+    /**
+     * Hilfsmethode zum Schreiben von Daten in die Output-Brigade
+     */
+    private function writeToBrigade($brigade, string $data): void
+    {
+        if (!empty($data)) {
+            $bucket = stream_bucket_new($this->stream, $data);
+            stream_bucket_append($brigade, $bucket);
+        }
+    }
+
+    /**
+     * Gibt einen Parameter zurück
+     */
+    private function getParam(string $key, $default = null)
+    {
+        return $this->params[$key] ?? $default;
+    }
+}
diff --git a/.archive/StreamWrapper/Filter/Filters/Base64EncodeFilter.php b/.archive/StreamWrapper/Filter/Filters/Base64EncodeFilter.php
new file mode 100644
index 00000000..4faf6ef2
--- /dev/null
+++ b/.archive/StreamWrapper/Filter/Filters/Base64EncodeFilter.php
@@ -0,0 +1,94 @@
+<?php
+declare(strict_types=1);
+
+namespace Archive\StreamWrapper\Filter\Filters;
+
+use Archive\StreamWrapper\Filter\StreamFilterInterface;
+
+/**
+ * Stream-Filter für Base64-Kodierung
+ */
+class Base64EncodeFilter extends \php_user_filter implements StreamFilterInterface
+{
+    private string $filterName = 'transform.base64encode';
+    private array $supportedModes = ['write'];
+    private array $params = [];
+
+    private bool $urlSafe = false;
+
+    public function onCreate(): bool
+    {
+        // Parameter aus dem Stream-Context extrahieren
+        if (isset($this->params)) {
+            $this->params = $this->params;
+        }
+
+        $this->urlSafe = $this->getParam('url_safe', false);
+        return true;
+    }
+
+    public function onClose(): void
+    {
+        // Cleanup falls nötig
+    }
+
+    public function getFilterName(): string
+    {
+        return $this->filterName;
+    }
+
+    public function getSupportedModes(): array
+    {
+        return $this->supportedModes;
+    }
+
+    public function filter($in, $out, &$consumed, bool $closing): int
+    {
+        $data = $this->readFromBrigade($in);
+        $consumed = strlen($data);
+
+        if (!empty($data)) {
+            $encoded = base64_encode($data);
+
+            if ($this->urlSafe) {
+                $encoded = strtr($encoded, '+/', '-_');
+                $encoded = rtrim($encoded, '=');
+            }
+
+            $this->writeToBrigade($out, $encoded);
+        }
+
+        return PSFS_PASS_ON;
+    }
+
+    /**
+     * Hilfsmethode zum Lesen von Daten aus der Input-Brigade
+     */
+    private function readFromBrigade($brigade): string
+    {
+        $data = '';
+        while ($bucket = stream_bucket_make_writeable($brigade)) {
+            $data .= $bucket->data;
+        }
+        return $data;
+    }
+
+    /**
+     * Hilfsmethode zum Schreiben von Daten in die Output-Brigade
+     */
+    private function writeToBrigade($brigade, string $data): void
+    {
+        if (!empty($data)) {
+            $bucket = stream_bucket_new($this->stream, $data);
+            stream_bucket_append($brigade, $bucket);
+        }
+    }
+
+    /**
+     * Gibt einen Parameter zurück
+     */
+    private function getParam(string $key, $default = null)
+    {
+        return $this->params[$key] ?? $default;
+    }
+}
diff --git a/.archive/StreamWrapper/Filter/Filters/GzipDecompressFilter.php b/.archive/StreamWrapper/Filter/Filters/GzipDecompressFilter.php
new file mode 100644
index 00000000..61099869
--- /dev/null
+++ b/.archive/StreamWrapper/Filter/Filters/GzipDecompressFilter.php
@@ -0,0 +1,89 @@
+<?php
+declare(strict_types=1);
+
+namespace Archive\StreamWrapper\Filter\Filters;
+
+use Archive\StreamWrapper\Filter\StreamFilterInterface;
+
+/**
+ * Stream-Filter für Gzip-Dekomprimierung
+ */
+class GzipDecompressFilter extends \php_user_filter implements StreamFilterInterface
+{
+    private string $filterName = 'gzip.decompress';
+    private array $supportedModes = ['read'];
+    private array $params = [];
+
+    public function onCreate(): bool
+    {
+        // Parameter aus dem Stream-Context extrahieren
+        if (isset($this->params)) {
+            $this->params = $this->params;
+        }
+
+        return true;
+    }
+
+    public function onClose(): void
+    {
+        // Cleanup falls nötig
+    }
+
+    public function getFilterName(): string
+    {
+        return $this->filterName;
+    }
+
+    public function getSupportedModes(): array
+    {
+        return $this->supportedModes;
+    }
+
+    public function filter($in, $out, &$consumed, bool $closing): int
+    {
+        $data = $this->readFromBrigade($in);
+        $consumed = strlen($data);
+
+        if (!empty($data)) {
+            $decompressed = gzuncompress($data);
+            if ($decompressed === false) {
+                return PSFS_ERR_FATAL;
+            }
+
+            $this->writeToBrigade($out, $decompressed);
+        }
+
+        return PSFS_PASS_ON;
+    }
+
+    /**
+     * Hilfsmethode zum Lesen von Daten aus der Input-Brigade
+     */
+    private function readFromBrigade($brigade): string
+    {
+        $data = '';
+        while ($bucket = stream_bucket_make_writeable($brigade)) {
+            $data .= $bucket->data;
+        }
+        return $data;
+    }
+
+    /**
+     * Hilfsmethode zum Schreiben von Daten in die Output-Brigade
+     */
+    private function writeToBrigade($brigade, string $data): void
+    {
+        if (!empty($data)) {
+            $bucket = stream_bucket_new($this->stream, $data);
+            stream_bucket_append($brigade, $bucket);
+        }
+    }
+
+    /**
+     * Gibt einen Parameter zurück
+     */
+    private function getParam(string $key, $default = null)
+    {
+        return $this->params[$key] ?? $default;
+    }
+}
diff --git a/.archive/StreamWrapper/Filter/StreamFilterFactory.php b/.archive/StreamWrapper/Filter/StreamFilterFactory.php
new file mode 100644
index 00000000..f5181ffb
--- /dev/null
+++ b/.archive/StreamWrapper/Filter/StreamFilterFactory.php
@@ -0,0 +1,172 @@
+<?php
+declare(strict_types=1);
+
+namespace Archive\StreamWrapper\Filter;
+
+/**
+ * Factory für die einfache Erstellung und Nutzung von Stream-Filtern
+ */
+final class StreamFilterFactory
+{
+    /**
+     * Initialisiert alle Stream-Filter
+     */
+    public static function initialize(): void
+    {
+        StreamFilterRegistry::initializeDefaults();
+    }
+
+    /**
+     * Erstellt einen Kompressions-Filter
+     */
+    public static function compression(int $level = 6): array
+    {
+        return [
+            'name' => 'gzip.compress',
+            'params' => ['level' => $level]
+        ];
+    }
+
+    /**
+     * Erstellt einen Dekompressions-Filter
+     */
+    public static function decompression(): array
+    {
+        return ['name' => 'gzip.decompress'];
+    }
+
+    /**
+     * Erstellt einen Verschlüsselungs-Filter
+     */
+    public static function encryption(string $key, string $method = 'AES-256-CBC'): array
+    {
+        return [
+            'name' => 'encrypt.aes256',
+            'params' => [
+                'key' => $key,
+                'method' => $method
+            ]
+        ];
+    }
+
+    /**
+     * Erstellt einen Entschlüsselungs-Filter
+     */
+    public static function decryption(string $key, string $method = 'AES-256-CBC'): array
+    {
+        return [
+            'name' => 'decrypt.aes256',
+            'params' => [
+                'key' => $key,
+                'method' => $method
+            ]
+        ];
+    }
+
+    /**
+     * Erstellt einen JSON-Validierungs-Filter
+     */
+    public static function jsonValidation(bool $strict = true, bool $throwOnError = false): array
+    {
+        return [
+            'name' => 'validate.json',
+            'params' => [
+                'strict' => $strict,
+                'throw_on_error' => $throwOnError
+            ]
+        ];
+    }
+
+    /**
+     * Erstellt einen Base64-Encoding-Filter
+     */
+    public static function base64Encode(bool $urlSafe = false): array
+    {
+        return [
+            'name' => 'transform.base64encode',
+            'params' => ['url_safe' => $urlSafe]
+        ];
+    }
+
+    /**
+     * Erstellt einen Access-Log-Filter
+     */
+    public static function accessLog(string $logFile = null): array
+    {
+        $params = [];
+        if ($logFile) {
+            $params['log_file'] = $logFile;
+        }
+
+        return [
+            'name' => 'log.access',
+            'params' => $params
+        ];
+    }
+
+    /**
+     * Wendet Filter auf einen Stream an
+     */
+    public static function applyFilters($stream, array $filters, int $mode = STREAM_FILTER_ALL): array
+    {
+        return StreamFilterRegistry::createFilterChain($stream, $filters, $mode);
+    }
+
+    /**
+     * Wendet einen einzelnen Filter an
+     */
+    public static function applyFilter($stream, array $filterConfig, int $mode = STREAM_FILTER_ALL)
+    {
+        $filterName = $filterConfig['name'] ?? $filterConfig;
+        $params = $filterConfig['params'] ?? [];
+
+        return StreamFilterRegistry::appendFilter($stream, $filterName, $mode, $params);
+    }
+
+    /**
+     * Erstellt einen Stream mit vordefinierten Filtern
+     */
+    public static function createFilteredStream(string $url, string $mode, array $filters = [], array $contextOptions = [])
+    {
+        $context = null;
+        if (!empty($contextOptions)) {
+            $context = stream_context_create($contextOptions);
+        }
+
+        $stream = fopen($url, $mode, false, $context);
+
+        if ($stream && !empty($filters)) {
+            self::applyFilters($stream, $filters);
+        }
+
+        return $stream;
+    }
+
+    /**
+     * Vordefinierte Filter-Kombinationen
+     */
+    public static function secureDataFilter(string $encryptionKey): array
+    {
+        return [
+            self::jsonValidation(true, true),
+            self::compression(9),
+            self::encryption($encryptionKey),
+            self::accessLog()
+        ];
+    }
+
+    public static function compressionFilter(int $level = 6): array
+    {
+        return [
+            self::compression($level),
+            self::accessLog()
+        ];
+    }
+
+    public static function loggingFilter(string $logFile = null): array
+    {
+        return [
+            self::accessLog($logFile)
+        ];
+    }
+}
diff --git a/.archive/StreamWrapper/Filter/StreamFilterInterface.php b/.archive/StreamWrapper/Filter/StreamFilterInterface.php
new file mode 100644
index 00000000..4f5b6252
--- /dev/null
+++ b/.archive/StreamWrapper/Filter/StreamFilterInterface.php
@@ -0,0 +1,43 @@
+<?php
+declare(strict_types=1);
+
+namespace Archive\StreamWrapper\Filter;
+
+/**
+ * Interface für benutzerdefinierte Stream-Filter
+ */
+interface StreamFilterInterface
+{
+    /**
+     * Filtert Daten beim Lesen/Schreiben
+     *
+     * @param resource $in Input-Bucket-Brigade
+     * @param resource $out Output-Bucket-Brigade
+     * @param int $consumed Anzahl der verbrauchten Bytes
+     * @param bool $closing Gibt an, ob der Stream geschlossen wird
+     * @return int PSFS_PASS_ON, PSFS_FEED_ME oder PSFS_ERR_FATAL
+     */
+    public function filter($in, $out, &$consumed, bool $closing): int;
+
+    /**
+     * Wird beim Anhängen des Filters an einen Stream aufgerufen
+     *
+     * @return bool True bei Erfolg, false bei Fehler
+     */
+    public function onCreate(): bool;
+
+    /**
+     * Wird beim Entfernen des Filters aufgerufen
+     */
+    public function onClose(): void;
+
+    /**
+     * Gibt den Filter-Namen zurück
+     */
+    public function getFilterName(): string;
+
+    /**
+     * Gibt die unterstützten Modi zurück (read, write, read|write)
+     */
+    public function getSupportedModes(): array;
+}
diff --git a/.archive/StreamWrapper/Filter/StreamFilterRegistry.php b/.archive/StreamWrapper/Filter/StreamFilterRegistry.php
new file mode 100644
index 00000000..015f1471
--- /dev/null
+++ b/.archive/StreamWrapper/Filter/StreamFilterRegistry.php
@@ -0,0 +1,167 @@
+<?php
+declare(strict_types=1);
+
+namespace Archive\StreamWrapper\Filter;
+
+use App\Framework\StreamWrapper\Exception\StreamWrapperException;
+use App\Framework\StreamWrapper\Filter\Filters;
+
+/**
+ * Registry zur Verwaltung und Registrierung von Stream-Filtern
+ */
+final class StreamFilterRegistry
+{
+    private static array $registeredFilters = [];
+    private static bool $initialized = false;
+
+    /**
+     * Registriert einen Stream-Filter
+     */
+    public static function register(string $filterName, string $filterClass): void
+    {
+        if (self::isRegistered($filterName)) {
+            stream_filter_remove($filterName);
+        }
+
+        if (!stream_filter_register($filterName, $filterClass)) {
+            throw new StreamWrapperException("Failed to register filter: $filterName");
+        }
+
+        self::$registeredFilters[$filterName] = $filterClass;
+    }
+
+    /**
+     * Entfernt die Registrierung eines Stream-Filters
+     */
+    public static function unregister(string $filterName): void
+    {
+        if (self::isRegistered($filterName)) {
+            // Hinweis: stream_filter_unregister existiert nicht in PHP
+            // Filter werden automatisch beim Script-Ende entfernt
+            unset(self::$registeredFilters[$filterName]);
+        }
+    }
+
+    /**
+     * Prüft, ob ein Filter registriert ist
+     */
+    public static function isRegistered(string $filterName): bool
+    {
+        return isset(self::$registeredFilters[$filterName]);
+    }
+
+    /**
+     * Gibt alle registrierten Filter zurück
+     */
+    public static function getRegisteredFilters(): array
+    {
+        return array_keys(self::$registeredFilters);
+    }
+
+    /**
+     * Gibt die Filter-Klasse zurück
+     */
+    public static function getFilterClass(string $filterName): ?string
+    {
+        return self::$registeredFilters[$filterName] ?? null;
+    }
+
+    /**
+     * Initialisiert alle Standard-Stream-Filter
+     */
+    public static function initializeDefaults(): void
+    {
+        if (self::$initialized) {
+            return;
+        }
+
+        // Komprimierungs-Filter
+        self::register('gzip.compress', Filters\GzipCompressFilter::class);
+        self::register('gzip.decompress', \Archive\StreamWrapper\Filter\Filters\GzipDecompressFilter::class);
+
+        // Verschlüsselungs-Filter
+        self::register('encrypt.aes256', Filters\AES256EncryptFilter::class);
+        self::register('decrypt.aes256', \Archive\StreamWrapper\Filter\Filters\AES256DecryptFilter::class);
+
+        // Validierungs-Filter
+        self::register('validate.json', Filters\JsonValidationFilter::class);
+        self::register('validate.xml', Filters\XmlValidationFilter::class);
+
+        // Transform-Filter
+        self::register('transform.base64encode', \Archive\StreamWrapper\Filter\Filters\Base64EncodeFilter::class);
+        self::register('transform.base64decode', Filters\Base64DecodeFilter::class);
+        self::register('transform.uppercase', Filters\UppercaseFilter::class);
+        self::register('transform.lowercase', Filters\LowercaseFilter::class);
+
+        // Logging-Filter
+        self::register('log.access', \Archive\StreamWrapper\Filter\Filters\AccessLogFilter::class);
+        self::register('log.debug', Filters\DebugLogFilter::class);
+
+        // Caching-Filter
+        self::register('cache.write', Filters\CacheWriteFilter::class);
+        self::register('cache.read', Filters\CacheReadFilter::class);
+
+        self::$initialized = true;
+    }
+
+    /**
+     * Entfernt alle Framework-Stream-Filter
+     */
+    public static function cleanup(): void
+    {
+        self::$registeredFilters = [];
+        self::$initialized = false;
+    }
+
+    /**
+     * Wendet einen Filter auf einen Stream an
+     */
+    public static function appendFilter($stream, string $filterName, int $mode = STREAM_FILTER_ALL, array $params = [])
+    {
+        if (!self::isRegistered($filterName)) {
+            throw new StreamWrapperException("Filter not registered: $filterName");
+        }
+
+        return stream_filter_append($stream, $filterName, $mode, $params);
+    }
+
+    /**
+     * Wendet einen Filter am Anfang eines Streams an
+     */
+    public static function prependFilter($stream, string $filterName, int $mode = STREAM_FILTER_ALL, array $params = [])
+    {
+        if (!self::isRegistered($filterName)) {
+            throw new StreamWrapperException("Filter not registered: $filterName");
+        }
+
+        return stream_filter_prepend($stream, $filterName, $mode, $params);
+    }
+
+    /**
+     * Entfernt einen Filter von einem Stream
+     */
+    public static function removeFilter($filter): bool
+    {
+        return stream_filter_remove($filter);
+    }
+
+    /**
+     * Erstellt eine Filter-Kette für einen Stream
+     */
+    public static function createFilterChain($stream, array $filters, int $mode = STREAM_FILTER_ALL): array
+    {
+        $appliedFilters = [];
+
+        foreach ($filters as $filterConfig) {
+            $filterName = $filterConfig['name'] ?? $filterConfig;
+            $params = $filterConfig['params'] ?? [];
+
+            $filter = self::appendFilter($stream, $filterName, $mode, $params);
+            if ($filter) {
+                $appliedFilters[] = $filter;
+            }
+        }
+
+        return $appliedFilters;
+    }
+}
diff --git a/.archive/StreamWrapper/README.md b/.archive/StreamWrapper/README.md
new file mode 100644
index 00000000..23801dd0
--- /dev/null
+++ b/.archive/StreamWrapper/README.md
@@ -0,0 +1,29 @@
+# StreamWrapper Module
+
+Das StreamWrapper-Modul ermöglicht den transparenten Zugriff auf verschiedene Framework-Services über einheitliche Stream-URLs. Dadurch können Sie native PHP-Funktionen wie `file_get_contents()`, `fopen()`, `copy()` etc. mit Framework-Services verwenden.
+
+## Installation
+
+```php
+// Initialisierung
+StreamWrapperFactory::initialize();
+
+// Filter verwenden
+$data = StreamWrapperFactory::readWithFilters(
+'cache://session/user123',
+[
+StreamFilterFactory::decompression(),
+StreamFilterFactory::decryption($key),
+StreamFilterFactory::jsonValidation()
+]
+);
+
+// Neue Filter sind verfügbar
+$encoded = StreamWrapperFactory::writeWithFilters(
+'cache://data',
+$binaryData,
+[
+StreamFilterFactory::base64Encode(true), // URL-safe
+StreamFilterFactory::compression(9)
+]
+);
diff --git a/.archive/StreamWrapper/StreamWrapperFactory.php b/.archive/StreamWrapper/StreamWrapperFactory.php
new file mode 100644
index 00000000..4c46bca4
--- /dev/null
+++ b/.archive/StreamWrapper/StreamWrapperFactory.php
@@ -0,0 +1,167 @@
+<?php
+declare(strict_types=1);
+
+namespace Archive\StreamWrapper;
+
+use App\Framework\StreamWrapper\StreamWrapperRegistry;
+
+/**
+ * Factory für die einfache Erstellung und Nutzung von Stream-Wrappern
+ */
+final class StreamWrapperFactory
+{
+    /**
+     * Initialisiert alle Stream-Wrapper und Filter
+     */
+    public static function initialize(): void
+    {
+        StreamWrapperRegistry::initializeDefaults();
+        \Archive\StreamWrapper\Filter\StreamFilterRegistry::initializeDefaults();
+    }
+
+    /**
+     * Erstellt eine Cache-Stream-URL
+     */
+    public static function cache(string $key, ?string $namespace = null): string
+    {
+        $host = $namespace ?? 'default';
+        return "cache://{$host}/{$key}";
+    }
+
+    /**
+     * Erstellt eine Config-Stream-URL
+     */
+    public static function config(string $key, string $source = 'default'): string
+    {
+        return "config://{$source}/{$key}";
+    }
+
+    /**
+     * Erstellt eine Log-Stream-URL
+     */
+    public static function log(string $filename, string $channel = 'default'): string
+    {
+        return "log://{$channel}/{$filename}";
+    }
+
+
+    /**
+     * Erstellt eine Database-Stream-URL
+     */
+    public static function database(string $table, string $operation = 'select', array $params = [], string $connection = 'default'): string
+    {
+        $url = "db://{$connection}/{$table}/{$operation}";
+
+        if (!empty($params)) {
+            $url .= '?' . http_build_query($params);
+        }
+
+        return $url;
+    }
+
+    /**
+     * Erstellt eine HTTP-Client-Stream-URL
+     */
+    public static function httpClient(string $host, string $path = ''): string
+    {
+        return "http-client://{$host}/{$path}";
+    }
+
+    /**
+     * Liest Daten von einer Stream-URL
+     */
+    public static function read(string $url, array $contextOptions = []): string|false
+    {
+        if (!empty($contextOptions)) {
+            $context = stream_context_create($contextOptions);
+            return file_get_contents($url, false, $context);
+        }
+
+        return file_get_contents($url);
+    }
+
+    /**
+     * Schreibt Daten zu einer Stream-URL
+     */
+    public static function write(string $url, string $data, array $contextOptions = []): int|false
+    {
+        if (!empty($contextOptions)) {
+            $context = stream_context_create($contextOptions);
+            return file_put_contents($url, $data, 0, $context);
+        }
+
+        return file_put_contents($url, $data);
+    }
+
+    /**
+     * Prüft, ob eine Stream-URL existiert
+     */
+    public static function exists(string $url): bool
+    {
+        return file_exists($url);
+    }
+
+    /**
+     * Kopiert zwischen Stream-URLs
+     */
+    public static function copy(string $from, string $to): bool
+    {
+        return copy($from, $to);
+    }
+
+    /**
+     * Löscht eine Stream-URL
+     */
+    public static function delete(string $url): bool
+    {
+        return unlink($url);
+    }
+
+    /**
+     * Erstellt einen Stream mit Filtern
+     */
+    public static function createFilteredStream(string $url, string $mode, array $filters = [], array $contextOptions = [])
+    {
+        return \Archive\StreamWrapper\Filter\StreamFilterFactory::createFilteredStream($url, $mode, $filters, $contextOptions);
+    }
+
+    /**
+     * Wendet Filter auf einen bestehenden Stream an
+     */
+    public static function applyFilters($stream, array $filters, int $mode = STREAM_FILTER_ALL): array
+    {
+        return \Archive\StreamWrapper\Filter\StreamFilterFactory::applyFilters($stream, $filters, $mode);
+    }
+
+    /**
+     * Liest von einer URL mit angewendeten Filtern
+     */
+    public static function readWithFilters(string $url, array $filters = [], array $contextOptions = []): string|false
+    {
+        $stream = self::createFilteredStream($url, 'r', $filters, $contextOptions);
+        if (!$stream) {
+            return false;
+        }
+
+        $content = stream_get_contents($stream);
+        fclose($stream);
+
+        return $content;
+    }
+
+    /**
+     * Schreibt zu einer URL mit angewendeten Filtern
+     */
+    public static function writeWithFilters(string $url, string $data, array $filters = [], array $contextOptions = []): int|false
+    {
+        $stream = self::createFilteredStream($url, 'w', $filters, $contextOptions);
+        if (!$stream) {
+            return false;
+        }
+
+        $result = fwrite($stream, $data);
+        fclose($stream);
+
+        return $result;
+    }
+}
diff --git a/.archive/StreamWrapper/StreamWrapperInterface.php b/.archive/StreamWrapper/StreamWrapperInterface.php
new file mode 100644
index 00000000..8aca9759
--- /dev/null
+++ b/.archive/StreamWrapper/StreamWrapperInterface.php
@@ -0,0 +1,95 @@
+<?php
+declare(strict_types=1);
+
+namespace Archive\StreamWrapper;
+
+/**
+ * Interface für benutzerdefinierte Stream-Wrapper
+ */
+interface StreamWrapperInterface
+{
+    /**
+     * Öffnet einen Stream
+     */
+    public function stream_open(string $path, string $mode, int $options, ?string &$opened_path): bool;
+
+    /**
+     * Liest Daten aus dem Stream
+     */
+    public function stream_read(int $count): string|false;
+
+    /**
+     * Schreibt Daten in den Stream
+     */
+    public function stream_write(string $data): int|false;
+
+    /**
+     * Gibt die aktuelle Position im Stream zurück
+     */
+    public function stream_tell(): int|false;
+
+    /**
+     * Prüft, ob das Ende des Streams erreicht ist
+     */
+    public function stream_eof(): bool;
+
+    /**
+     * Setzt die Position im Stream
+     */
+    public function stream_seek(int $offset, int $whence = SEEK_SET): bool;
+
+    /**
+     * Schließt den Stream
+     */
+    public function stream_close(): void;
+
+    /**
+     * Gibt Statistiken über den Stream zurück
+     */
+    public function stream_stat(): array|false;
+
+    /**
+     * Gibt Statistiken über eine URL zurück
+     */
+    public function url_stat(string $path, int $flags): array|false;
+
+    /**
+     * Erstellt ein Verzeichnis
+     */
+    public function mkdir(string $path, int $mode, int $options): bool;
+
+    /**
+     * Entfernt ein Verzeichnis
+     */
+    public function rmdir(string $path, int $options): bool;
+
+    /**
+     * Öffnet ein Verzeichnis zum Lesen
+     */
+    public function dir_opendir(string $path, int $options): bool;
+
+    /**
+     * Liest den nächsten Eintrag aus einem Verzeichnis
+     */
+    public function dir_readdir(): string|false;
+
+    /**
+     * Setzt den Verzeichnis-Handle zurück
+     */
+    public function dir_rewinddir(): bool;
+
+    /**
+     * Schließt ein Verzeichnis-Handle
+     */
+    public function dir_closedir(): bool;
+
+    /**
+     * Benennt eine Datei um oder verschiebt sie
+     */
+    public function rename(string $path_from, string $path_to): bool;
+
+    /**
+     * Löscht eine Datei
+     */
+    public function unlink(string $path): bool;
+}
diff --git a/.archive/StreamWrapper/Wrappers/ConfigStreamWrapper.php b/.archive/StreamWrapper/Wrappers/ConfigStreamWrapper.php
new file mode 100644
index 00000000..89281f17
--- /dev/null
+++ b/.archive/StreamWrapper/Wrappers/ConfigStreamWrapper.php
@@ -0,0 +1,123 @@
+<?php
+declare(strict_types=1);
+
+namespace Archive\StreamWrapper\Wrappers;
+
+use App\Framework\Config\ConfigManager;
+use App\Framework\StreamWrapper\Helper\StreamWrapperHelper;
+use Archive\StreamWrapper\Context\StreamContext;
+use Archive\StreamWrapper\StreamWrapperInterface;
+
+/**
+ * Stream-Wrapper für das Config-System
+ * Syntax: config://source/key.path
+ */
+class ConfigStreamWrapper implements StreamWrapperInterface
+{
+    public $context;
+    private string $content = '';
+    private int $position = 0;
+    private string $mode = 'r';
+    private array $parsedUrl = [];
+    private ?StreamContext $streamContext = null;
+
+    private ConfigManager $config;
+    private string $configKey;
+    private string $source;
+
+    public function stream_open(string $path, string $mode, int $options, ?string &$opened_path): bool
+    {
+        $this->streamContext = StreamWrapperHelper::initializeContext($this->context);
+        $this->parsedUrl = StreamWrapperHelper::parseUrl($path);
+        $this->mode = $mode;
+
+        $this->source = $this->parsedUrl['host'] ?: 'default';
+        $this->configKey = $this->parsedUrl['path'];
+
+        // Config-Manager initialisieren
+        $this->config = new ConfigManager();
+
+        // Konfigurationswert laden
+        if (str_contains($mode, 'r') || str_contains($mode, '+')) {
+            $this->content = $this->loadContent($this->configKey);
+        }
+
+        return true;
+    }
+
+    public function stream_read(int $count): string|false
+    {
+        return StreamWrapperHelper::streamRead($this->content, $this->position, $count);
+    }
+
+    public function stream_write(string $data): int|false
+    {
+        return StreamWrapperHelper::streamWrite($this->content, $this->position, $data);
+    }
+
+    public function stream_tell(): int|false
+    {
+        return $this->position;
+    }
+
+    public function stream_eof(): bool
+    {
+        return $this->position >= strlen($this->content);
+    }
+
+    public function stream_seek(int $offset, int $whence = SEEK_SET): bool
+    {
+        return StreamWrapperHelper::streamSeek($this->content, $this->position, $offset, $whence);
+    }
+
+    public function stream_close(): void
+    {
+        $this->content = '';
+        $this->position = 0;
+    }
+
+    public function stream_stat(): array|false
+    {
+        return StreamWrapperHelper::streamStat($this->content);
+    }
+
+    public function url_stat(string $path, int $flags): array|false
+    {
+        $parsedUrl = StreamWrapperHelper::parseUrl($path);
+        $source = $parsedUrl['host'] ?: 'default';
+        $configKey = $parsedUrl['path'];
+
+        $config = new ConfigManager();
+
+        if (!$config->has($configKey)) {
+            return false;
+        }
+
+        $value = $config->get($configKey);
+        $content = is_string($value) ? $value : json_encode($value);
+        $size = strlen($content);
+
+        return StreamWrapperHelper::createDefaultStat($size);
+    }
+
+    // Nicht unterstützte Operationen
+    public function mkdir(string $path, int $mode, int $options): bool { return false; }
+    public function rmdir(string $path, int $options): bool { return false; }
+    public function dir_opendir(string $path, int $options): bool { return false; }
+    public function dir_readdir(): string|false { return false; }
+    public function dir_rewinddir(): bool { return false; }
+    public function dir_closedir(): bool { return false; }
+    public function rename(string $path_from, string $path_to): bool { return false; }
+    public function unlink(string $path): bool { return false; }
+
+    private function loadContent(string $path): string
+    {
+        $value = $this->config->get($path);
+
+        if ($value === null) {
+            return '';
+        }
+
+        return is_string($value) ? $value : json_encode($value);
+    }
+}
diff --git a/.archive/StreamWrapper/Wrappers/DatabaseStreamWrapper.php b/.archive/StreamWrapper/Wrappers/DatabaseStreamWrapper.php
new file mode 100644
index 00000000..b3f8c610
--- /dev/null
+++ b/.archive/StreamWrapper/Wrappers/DatabaseStreamWrapper.php
@@ -0,0 +1,205 @@
+<?php
+declare(strict_types=1);
+
+namespace Archive\StreamWrapper\Wrappers;
+
+use App\Framework\Database\DatabaseManager;
+use App\Framework\StreamWrapper\Helper\StreamWrapperHelper;
+use Archive\StreamWrapper\Context\StreamContext;
+use Archive\StreamWrapper\StreamWrapperInterface;
+
+/**
+ * Stream-Wrapper für Database-Operationen
+ * Syntax: db://connection/table/operation?params
+ */
+class DatabaseStreamWrapper implements StreamWrapperInterface
+{
+    public $context;
+    private string $content = '';
+    private int $position = 0;
+    private string $mode = 'r';
+    private array $parsedUrl = [];
+    private ?StreamContext $streamContext = null;
+
+    private DatabaseManager $database;
+    private string $connection;
+    private string $table;
+    private string $operation;
+    private array $params = [];
+
+    public function stream_open(string $path, string $mode, int $options, ?string &$opened_path): bool
+    {
+        $this->streamContext = StreamWrapperHelper::initializeContext($this->context);
+        $this->parsedUrl = StreamWrapperHelper::parseUrl($path);
+        $this->mode = $mode;
+
+        $this->connection = $this->parsedUrl['host'] ?: 'default';
+
+        $pathParts = explode('/', $this->parsedUrl['path']);
+        $this->table = $pathParts[0] ?? '';
+        $this->operation = $pathParts[1] ?? 'select';
+
+        // Query-Parameter parsen
+        if ($this->parsedUrl['query']) {
+            parse_str($this->parsedUrl['query'], $this->params);
+        }
+
+        // Database-Manager initialisieren
+        $this->database = new DatabaseManager();
+
+        // Bei Lese-Operationen Query ausführen
+        if (str_contains($mode, 'r') || str_contains($mode, '+')) {
+            $this->content = $this->loadContent($this->operation);
+        }
+
+        return true;
+    }
+
+    public function stream_read(int $count): string|false
+    {
+        return StreamWrapperHelper::streamRead($this->content, $this->position, $count);
+    }
+
+    public function stream_write(string $data): int|false
+    {
+        return StreamWrapperHelper::streamWrite($this->content, $this->position, $data);
+    }
+
+    public function stream_tell(): int|false
+    {
+        return $this->position;
+    }
+
+    public function stream_eof(): bool
+    {
+        return $this->position >= strlen($this->content);
+    }
+
+    public function stream_seek(int $offset, int $whence = SEEK_SET): bool
+    {
+        return StreamWrapperHelper::streamSeek($this->content, $this->position, $offset, $whence);
+    }
+
+    public function stream_close(): void
+    {
+        // Bei Schreib-Modi Operation ausführen
+        if (str_contains($this->mode, 'w') || str_contains($this->mode, 'a') || str_contains($this->mode, '+')) {
+            $this->saveContent($this->operation, $this->content);
+        }
+
+        $this->content = '';
+        $this->position = 0;
+    }
+
+    public function stream_stat(): array|false
+    {
+        return StreamWrapperHelper::streamStat($this->content);
+    }
+
+    public function url_stat(string $path, int $flags): array|false
+    {
+        return StreamWrapperHelper::createDefaultStat(strlen($this->content));
+    }
+
+    // Nicht unterstützte Operationen
+    public function mkdir(string $path, int $mode, int $options): bool { return false; }
+    public function rmdir(string $path, int $options): bool { return false; }
+    public function dir_opendir(string $path, int $options): bool { return false; }
+    public function dir_readdir(): string|false { return false; }
+    public function dir_rewinddir(): bool { return false; }
+    public function dir_closedir(): bool { return false; }
+    public function rename(string $path_from, string $path_to): bool { return false; }
+    public function unlink(string $path): bool { return false; }
+
+    private function loadContent(string $operation): string
+    {
+        $connection = $this->streamContext?->getOption('db', 'connection', $this->connection);
+
+        $result = match($operation) {
+            'select', 'all' => $this->executeSelect(),
+            'count' => $this->executeCount(),
+            'exists' => $this->executeExists(),
+            default => []
+        };
+
+        return json_encode($result);
+    }
+
+    private function saveContent(string $operation, string $content): bool
+    {
+        $data = json_decode($content, true);
+
+        return match($operation) {
+            'insert' => $this->executeInsert($data),
+            'update' => $this->executeUpdate($data),
+            'delete' => $this->executeDelete($data),
+            'bulk-insert' => $this->executeBulkInsert($data),
+            default => false
+        };
+    }
+
+    private function executeSelect(): array
+    {
+        $query = $this->database->connection($this->connection)->table($this->table);
+
+        foreach ($this->params as $key => $value) {
+            if ($key === 'id') {
+                $query->where('id', $value);
+            } elseif (str_starts_with($key, 'where_')) {
+                $field = substr($key, 6);
+                $query->where($field, $value);
+            }
+        }
+
+        return $query->get()->toArray();
+    }
+
+    private function executeCount(): array
+    {
+        $count = $this->database->connection($this->connection)->table($this->table)->count();
+        return ['count' => $count];
+    }
+
+    private function executeExists(): array
+    {
+        $exists = $this->database->connection($this->connection)->table($this->table);
+
+        if (isset($this->params['id'])) {
+            $exists->where('id', $this->params['id']);
+        }
+
+        return ['exists' => $exists->exists()];
+    }
+
+    private function executeInsert(array $data): bool
+    {
+        return $this->database->connection($this->connection)->table($this->table)->insert($data);
+    }
+
+    private function executeUpdate(array $data): bool
+    {
+        $query = $this->database->connection($this->connection)->table($this->table);
+
+        if (isset($this->params['id'])) {
+            $query->where('id', $this->params['id']);
+        }
+
+        return $query->update($data) > 0;
+    }
+
+    private function executeDelete(array $data): bool
+    {
+        $query = $this->database->connection($this->connection)->table($this->table);
+
+        if (isset($this->params['id'])) {
+            $query->where('id', $this->params['id']);
+        }
+
+        return $query->delete() > 0;
+    }
+
+    private function executeBulkInsert(array $data): bool
+    {
+        return $this->database->connection($this->connection)->table($this->table)->insert($data);
+    }
+}
diff --git a/.archive/StreamWrapper/Wrappers/HttpStreamWrapper.php b/.archive/StreamWrapper/Wrappers/HttpStreamWrapper.php
new file mode 100644
index 00000000..981b8a9a
--- /dev/null
+++ b/.archive/StreamWrapper/Wrappers/HttpStreamWrapper.php
@@ -0,0 +1,164 @@
+<?php
+declare(strict_types=1);
+
+namespace Archive\StreamWrapper\Wrappers;
+
+use App\Framework\HttpClient\HttpClient;
+use App\Framework\StreamWrapper\Helper\StreamWrapperHelper;
+use Archive\StreamWrapper\Context\StreamContext;
+use Archive\StreamWrapper\StreamWrapperInterface;
+
+/**
+ * Stream-Wrapper für HTTP-Client-Operationen
+ * Syntax: http-client://host/path
+ */
+class HttpStreamWrapper implements StreamWrapperInterface
+{
+    public $context;
+    private string $content = '';
+    private int $position = 0;
+    private string $mode = 'r';
+    private array $parsedUrl = [];
+    private ?StreamContext $streamContext = null;
+
+    private HttpClient $httpClient;
+    private string $host;
+    private string $path;
+    private array $headers = [];
+    private int $timeout = 30;
+    private ?string $auth = null;
+
+    public function stream_open(string $path, string $mode, int $options, ?string &$opened_path): bool
+    {
+        $this->streamContext = StreamWrapperHelper::initializeContext($this->context);
+        $this->parsedUrl = StreamWrapperHelper::parseUrl($path);
+        $this->mode = $mode;
+
+        $this->host = $this->parsedUrl['host'];
+        $this->path = '/' . ltrim($this->parsedUrl['path'], '/');
+
+        // Optionen aus Context lesen
+        if ($this->streamContext) {
+            $this->headers = $this->streamContext->getOption('http-client', 'headers', []);
+            $this->timeout = $this->streamContext->getOption('http-client', 'timeout', 30);
+            $this->auth = $this->streamContext->getOption('http-client', 'auth');
+        }
+
+        // HTTP-Client initialisieren
+        $this->httpClient = new HttpClient();
+
+        // Bei Lese-Modi HTTP-Request ausführen
+        if (str_contains($mode, 'r') || str_contains($mode, '+')) {
+            $this->content = $this->loadContent($this->buildUrl());
+        }
+
+        return true;
+    }
+
+    public function stream_read(int $count): string|false
+    {
+        return StreamWrapperHelper::streamRead($this->content, $this->position, $count);
+    }
+
+    public function stream_write(string $data): int|false
+    {
+        return StreamWrapperHelper::streamWrite($this->content, $this->position, $data);
+    }
+
+    public function stream_tell(): int|false
+    {
+        return $this->position;
+    }
+
+    public function stream_eof(): bool
+    {
+        return $this->position >= strlen($this->content);
+    }
+
+    public function stream_seek(int $offset, int $whence = SEEK_SET): bool
+    {
+        return StreamWrapperHelper::streamSeek($this->content, $this->position, $offset, $whence);
+    }
+
+    public function stream_close(): void
+    {
+        // Bei Schreib-Modi POST/PUT-Request senden
+        if (str_contains($this->mode, 'w') || str_contains($this->mode, 'a') || str_contains($this->mode, '+')) {
+            $this->saveContent($this->buildUrl(), $this->content);
+        }
+
+        $this->content = '';
+        $this->position = 0;
+    }
+
+    public function stream_stat(): array|false
+    {
+        return StreamWrapperHelper::streamStat($this->content);
+    }
+
+    public function url_stat(string $path, int $flags): array|false
+    {
+        return StreamWrapperHelper::createDefaultStat(strlen($this->content));
+    }
+
+    // Nicht unterstützte Operationen
+    public function mkdir(string $path, int $mode, int $options): bool { return false; }
+    public function rmdir(string $path, int $options): bool { return false; }
+    public function dir_opendir(string $path, int $options): bool { return false; }
+    public function dir_readdir(): string|false { return false; }
+    public function dir_rewinddir(): bool { return false; }
+    public function dir_closedir(): bool { return false; }
+    public function rename(string $path_from, string $path_to): bool { return false; }
+    public function unlink(string $path): bool { return false; }
+
+    private function loadContent(string $url): string
+    {
+        $request = $this->httpClient->get($url);
+
+        if ($this->auth) {
+            $request->withHeader('Authorization', $this->auth);
+        }
+
+        foreach ($this->headers as $name => $value) {
+            $request->withHeader($name, $value);
+        }
+
+        $response = $request->timeout($this->timeout)->send();
+
+        return $response->body();
+    }
+
+    private function saveContent(string $url, string $content): bool
+    {
+        $request = $this->httpClient->post($url, $content);
+
+        if ($this->auth) {
+            $request->withHeader('Authorization', $this->auth);
+        }
+
+        foreach ($this->headers as $name => $value) {
+            $request->withHeader($name, $value);
+        }
+
+        $response = $request->timeout($this->timeout)->send();
+
+        return $response->successful();
+    }
+
+    private function buildUrl(): string
+    {
+        $scheme = 'https'; // Default zu HTTPS
+
+        if ($this->streamContext) {
+            $scheme = $this->streamContext->getOption('http-client', 'scheme', 'https');
+        }
+
+        $url = "{$scheme}://{$this->host}{$this->path}";
+
+        if ($this->parsedUrl['query']) {
+            $url .= '?' . $this->parsedUrl['query'];
+        }
+
+        return $url;
+    }
+}
diff --git a/.archive/docker-compose.yml b/.archive/docker-compose.yml
new file mode 100644
index 00000000..2ecdd262
--- /dev/null
+++ b/.archive/docker-compose.yml
@@ -0,0 +1,158 @@
+x-docker-settings: &docker-settings
+  build:
+    context: .
+    args:
+      - BUILDKIT_INLINE_CACHE=1
+
+services:
+  web:
+    container_name: web
+    build:
+      context: docker/nginx
+      dockerfile: Dockerfile
+    ports:
+      - "${APP_PORT:-8000}:80"
+      - "127.0.0.1:8080:80"
+      - "${APP_SSL_PORT:-443}:443/tcp"
+      - "443:443/udp"
+    environment:
+      - APP_ENV=${APP_ENV:-development}
+    volumes:
+      - ./:/var/www/html:cached
+      #- ./ssl:/etc/nginx/ssl:ro  # SSL-Zertifikate mounten
+      - ./ssl:/var/www/ssl:ro
+    depends_on:
+      php:
+        condition: service_started
+    restart: unless-stopped
+    networks:
+      - frontend
+      - backend
+    env_file:
+      - .env
+
+  php:
+    container_name: php
+    build:
+      context: .
+      dockerfile: docker/php/Dockerfile
+      args:
+        - ENV=${APP_ENV:-dev}
+        - COMPOSER_INSTALL_FLAGS=${COMPOSER_INSTALL_FLAGS:---no-scripts --no-autoloader}
+    user: "1000:1000"
+    volumes:
+      # Shared Volume für Composer-Cache über Container-Neustarts hinweg
+      - composer-cache:/root/.composer/cache
+      # Bindet das Projektverzeichnis für Live-Änderungen ein
+      - ./:/var/www/html:cached
+      # Verhindert Überschreiben der Vendor-Verzeichnisse
+      #- /var/www/html/vendor
+      #- cache-volume:/var/www/html/cache:rw
+    environment:
+      PHP_IDE_CONFIG: "serverName=docker"
+      APP_ENV: ${APP_ENV:-development}
+    healthcheck:
+      test: [ "CMD", "php", "-v" ]
+      interval: 10s
+      timeout: 5s
+      retries: 5
+    restart: unless-stopped
+    networks:
+      - backend
+      - cache
+    env_file:
+      - .env
+
+  db:
+    container_name: db
+    image: mariadb:latest
+    restart: unless-stopped
+    environment:
+      MYSQL_ROOT_PASSWORD: qwee65132ertert    # ändere das bitte!
+      MYSQL_DATABASE: database      # optionale Initial-Datenbank
+      MYSQL_USER: mdb-user              # optionaler zusätzlicher User
+      MYSQL_PASSWORD: dfghreh5465fghfgh         # Passwort für den zusätzlichen User
+    ports:
+      - "33060:3306"
+    volumes:
+      - db_data:/var/lib/mysql
+    healthcheck:
+      test: [ "CMD", "mariadb-admin", "ping", "-h", "127.0.0.1", "-u", "root", "-pqwee65132ertert" ]
+      interval: 10s
+      timeout: 5s
+      retries: 5
+      start_period: 30s
+    networks:
+      - backend
+
+  redis:
+    image: redis:8-alpine
+    volumes:
+      - ./docker/redis/redis.conf:/usr/local/etc/redis/redis.conf
+      - redis_data:/data
+    command: ["redis-server", "/usr/local/etc/redis/redis.conf"]
+    healthcheck:
+      test: ["CMD", "redis-cli", "ping"]
+      interval: 30s
+      timeout: 5s
+      retries: 3
+
+    restart: unless-stopped
+    networks:
+      - cache
+    env_file:
+      - .env
+
+  queue-worker:
+    container_name: queue-worker
+    build:
+      context: .
+      dockerfile: docker/worker/Dockerfile
+    user: "1000:1000"  # Same user ID as PHP container
+    depends_on:
+      php:
+        condition: service_healthy
+      redis:
+        condition: service_healthy
+      db:
+        condition: service_healthy
+    volumes:
+      - ./:/var/www/html:cached
+      - ./storage/logs:/var/www/html/storage/logs:rw
+      - ./src/Framework/CommandBus/storage:/var/www/html/src/Framework/CommandBus/storage:rw
+    environment:
+      - APP_ENV=${APP_ENV:-development}
+      - WORKER_DEBUG=${WORKER_DEBUG:-false}
+      - WORKER_SLEEP_TIME=${WORKER_SLEEP_TIME:-100000}
+      - WORKER_MAX_JOBS=${WORKER_MAX_JOBS:-1000}
+    restart: unless-stopped
+    networks:
+      - backend
+      - cache
+    env_file:
+      - .env
+    # Graceful shutdown timeout
+    stop_grace_period: 30s
+    # Resource limits for the worker
+    deploy:
+      resources:
+        limits:
+          memory: 512M
+        reservations:
+          memory: 256M
+
+networks:
+  frontend:
+    driver: bridge
+  backend:
+    driver: bridge
+  cache:
+    driver: bridge
+
+volumes:
+  redis_data:
+  composer-cache:
+  #cache-volume:
+  db_data:
+  worker-logs:
+  worker-queue:
diff --git a/.archive/docker/DOCKER-TODO.md b/.archive/docker/DOCKER-TODO.md
new file mode 100644
index 00000000..ac49566d
--- /dev/null
+++ b/.archive/docker/DOCKER-TODO.md
@@ -0,0 +1,48 @@
+# Optimierungsvorschläge für die Docker-Compose Umgebung
+
+## ToDo-Liste
+
+- [ ] **Datenbank Passwörter & Secrets absichern**
+  - Datenbankpasswörter nicht im Klartext in der YAML speichern, sondern `secrets`-Mechanismus verwenden.
+  - `.env` Werte für Datenbanken statt statischer Angaben verwenden.
+  - Beispiel: `MYSQL_ROOT_PASSWORD_FILE` und `MYSQL_PASSWORD_FILE` setzen und Secrets einbinden.
+
+- [ ] **Performance & Caching verbessern**
+  - `cache_from` und `cache_to` im Build-Prozess (BuildKit) einrichten.
+  - Für PHP einen dedizierten Volume für den Composer-Cache nutzen.
+  - Nginx-Cache als eigenes Volume deklarieren.
+  - Die Vendor-Ordner aus Mounts ausschließen oder gesondert berücksichtigen, damit lokale Änderungen keine Build-Optimierungen verhindern.
+
+- [ ] **Netzwerk- und Bind-Mounts optimieren**
+  - Bei Nginx nur das Public-Verzeichnis (`public/`) einbinden, nicht das gesamte Projektverzeichnis.
+  - Nicht benötigte Verzeichnisse (wie z.B. `vendor/`) explizit ausschließen.
+  - Healthchecks und Startbedingungen konsistent definieren.
+
+- [ ] **Image-Versionen festlegen**
+  - Keine `latest`-Images nutzen, sondern möglichst immer eine feste Version angeben (z.B. `mariadb:11.3` statt `mariadb:latest`).
+  - Gilt auch für Redis, PHP und weitere Services.
+
+- [ ] **Ressourcenlimits setzen**
+  - `deploy.resources` für Speicher und CPU bei allen Services, nicht nur beim Worker.
+
+- [ ] **Security-Best-Practices**
+  - Nicht produktive Ports (z.B. bei Entwicklung) durch `.env` variabel und gezielt auf localhost begrenzen.
+  - Feste Netzwerkbereiche und eigene Netzwerke für sensible Kommunikation (z.B. Backend, Cache).
+
+- [ ] **Multi-Stage Builds in Dockerfiles nutzen**
+  - Die Images im PHP- und Worker-Bereich sollten über Multi-Stage-Builds möglichst klein gehalten werden (z.B. `FROM php:X-cli AS base`, dann Production-Image).
+
+- [ ] **Environment-Konfiguration für Dev/Prod trennen**
+  - Eine `docker-compose.override.yml` für Entwicklung mit vollem Source-Mount und Debug-Konfiguration anlegen.
+  - Für Produktion keine Source-Mounts, keine Debug-Variablen, optimierte Settings.
+
+- [ ] **Log-Rotation aktivieren**
+  - Logging-Driver auf `json-file` einstellen und Optionen für Größe/Rotation setzen.
+
+- [ ] **Monitoring & Healthchecks**
+  - Für alle Services sinnvolle Healthchecks ergänzen.
+  - (Optional) Monitoring und/oder Alerting ergänzen.
+
+---
+
+**Tipp:** Die oben stehenden Punkte können Schritt für Schritt umgesetzt und pro optimiertem Bereich abgehakt werden.
diff --git a/.archive/docker/nginx/docker-entrypoint.sh b/.archive/docker/nginx/docker-entrypoint.sh
new file mode 100644
index 00000000..d7641c97
--- /dev/null
+++ b/.archive/docker/nginx/docker-entrypoint.sh
@@ -0,0 +1,58 @@
+#!/bin/sh
+set -e
+#!/bin/sh
+set -e
+
+# Umgebungsvariablen-Substitution in Nginx-Konfiguration
+if [ -n "$APP_ENV" ]; then
+    echo "Setting APP_ENV to: $APP_ENV"
+    sed -i "s/\${APP_ENV}/$APP_ENV/g" /etc/nginx/conf.d/default.conf
+fi
+
+# Warte auf PHP-FPM Container
+echo "Waiting for PHP-FPM to be ready..."
+while ! nc -z php 9000; do
+    sleep 1
+done
+echo "PHP-FPM is ready!"
+
+# SSL-Zertifikate prüfen
+if [ ! -f "/var/www/ssl/fullchain.pem" ] || [ ! -f "/var/www/ssl/privkey.pem" ]; then
+    echo "Warning: SSL certificates not found. HTTPS may not work properly."
+fi
+
+# Nginx-Konfiguration testen
+echo "Testing Nginx configuration..."
+nginx -t
+
+# Nginx starten
+echo "Starting Nginx..."
+exec "$@"
+until nc -z -w 2 php 9000; do
+  echo "Warte auf PHP-FPM..."
+  sleep 1
+done
+
+# Optional: eigene Umgebungsvariable mit Default setzen
+export APP_ENV="${APP_ENV:-production}"
+
+echo "Starte Nginx mit APP_ENV=$APP_ENV"
+
+# Ersetze Platzhalter in temporäre Datei
+envsubst '${APP_ENV}' < /etc/nginx/conf.d/default.conf > /tmp/default.conf
+
+# Ersetzte Originalkonfiguration
+cp /tmp/default.conf /etc/nginx/conf.d/default.conf
+
+# WICHTIG: Rechte für stdout/stderr anpassen
+chmod a+rw /dev/stdout /dev/stderr
+
+# Nginx-Ordner Rechte anpassen
+mkdir -p /var/cache/nginx /var/log/nginx
+chown -R nginx:nginx /var/cache/nginx /var/log/nginx
+
+# Stelle sicher, dass das SSL-Verzeichnis existiert
+mkdir -p /var/www/ssl
+
+# Jetzt kann nginx sicher starten
+exec nginx -g 'daemon off;'
diff --git a/.archive/docker/nginx/nginx.conf b/.archive/docker/nginx/nginx.conf
new file mode 100644
index 00000000..d0f186f0
--- /dev/null
+++ b/.archive/docker/nginx/nginx.conf
@@ -0,0 +1,78 @@
+# Standard Nginx User
+user nginx;
+worker_processes auto;
+error_log /var/log/nginx/error.log notice;
+pid /var/run/nginx.pid;
+
+# Worker-Prozess-Einstellungen
+events {
+    worker_connections 1024;
+    use epoll;
+    multi_accept on;
+}
+
+http {
+    # MIME-Types
+    include /etc/nginx/mime.types;
+    default_type application/octet-stream;
+
+    # Server-Tokens für Sicherheit ausblenden
+    server_tokens off;
+
+    # Rate-Limiting
+    limit_req_zone $binary_remote_addr zone=mylimit:10m rate=10r/s;
+
+    # Logging-Format
+    log_format main '$remote_addr - $remote_user [$time_local] "$request" '
+                    '$status $body_bytes_sent "$http_referer" '
+                    '"$http_user_agent" "$http_x_forwarded_for" '
+                    'rt=$request_time uct="$upstream_connect_time" '
+                    'uht="$upstream_header_time" urt="$upstream_response_time"';
+
+    # Container-optimierte Logs
+    access_log /dev/stdout main;
+    error_log /dev/stderr warn;
+
+    # Performance-Optimierungen
+    sendfile on;
+    tcp_nopush on;
+    tcp_nodelay on;
+    keepalive_timeout 65;
+    types_hash_max_size 2048;
+    client_max_body_size 64M;
+
+    # Gzip-Kompression
+    gzip on;
+    gzip_vary on;
+    gzip_min_length 1024;
+    gzip_proxied any;
+    gzip_comp_level 6;
+    gzip_types
+        text/plain
+        text/css
+        text/xml
+        text/javascript
+        application/json
+        application/javascript
+        application/xml+rss
+        application/atom+xml
+        image/svg+xml
+        application/rss+xml
+        application/vnd.ms-fontobject
+        application/x-font-ttf
+        font/opentype;
+
+    # Basis-Sicherheits-Header
+    add_header X-Frame-Options "SAMEORIGIN" always;
+    add_header X-XSS-Protection "1; mode=block" always;
+    add_header X-Content-Type-Options "nosniff" always;
+    add_header Referrer-Policy "no-referrer-when-downgrade" always;
+
+    # SSL-Session-Cache
+    ssl_session_cache shared:SSL:10m;
+    ssl_session_timeout 10m;
+    ssl_session_tickets off;
+
+    # Server-Konfigurationen einbinden
+    include /etc/nginx/conf.d/*.conf;
+}
diff --git a/.archive/docker/nginx/ssl/localhost+2-key.pem b/.archive/docker/nginx/ssl/localhost+2-key.pem
new file mode 100644
index 00000000..ed2534ce
--- /dev/null
+++ b/.archive/docker/nginx/ssl/localhost+2-key.pem
@@ -0,0 +1,28 @@
+-----BEGIN PRIVATE KEY-----
+MIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQDAzwS8FGSCDwDg
+7QX8OpGkX1SbSwbUyzXNjEta319BvAH2OfcFFCj6u/iqfL7gKOM83t8u71VBFsCx
+ZlxX2Ilyu2+r72sCdGBXcK6riTHrkjTs4uV6YV98eJuYhvAzSijpsRQjwnwQ587c
+axtCXZhOzee3Tnbtzq4plqmOKR10D+cvrOZxuoKI914blXpGe8ds3vWEixewrex0
+CYhzPj/zEF3yfCoSXeTmFBUbmmH/JwcCK8uO5t6XR1Dyo3M4GOMrmGtO7U4nuL6e
+7JsbZfPaEW9wKtDjEwFDJSLy0ALEpiNWvbW4OaZWNkJk0jfKYwyBunNSs62B4307
+oF8lqVo1AgMBAAECggEAbPlU0ryv5fZ256nvlRTBVmbvGep4zPKh0TA3MwBHBY8u
+iK1QWVWAp95v+GQTOfzCGphZCl0JEYW7mUiibqAbZ3Za8pGaKMP/48vzXU5ooZ18
+PlsrmlTItEAyqS2zOznyD8se9+snViK+f0QmHwdpWzjze15kx5nmQ+k8ofXJCNwq
+q3dJIMI/WNuc0e/mMHYjZBsIwuoUi6YJHCE6RkWhGcnvlyXdKUV73/n8Loy6DUtW
+VmshXag7+GfbVZIesMCjfnJ0gr9OG+XrFl6AcggzFA1ZHRoQliraVYGB2duQlIpW
+o1wJMhFSGFPZxvl67hwXHJeo7ghHHfqNYXS1OuhV7QKBgQDBrvyzLtav51LzqOUY
+2HPvaH86arbARc4Fy6ZJ0TaSlmKQ5GzRG0lG2CR03oZz+OcMV/BU8xUMM7CX0zUq
+9RAmbE7rvXYOvqTe8pcdHeKKflzsr5p0HNROaeZdpMu8xoK1KLelAo6UCEBUGEny
+oMtQWapuYvmdlHR2el2ICRGNzwKBgQD+1/iM1LcF9CYvEc8Sly9XuoRsdUCxavQa
+sssv7eG5kkL8HroNs1pGZU8lNuZaT1V0ekWVOFk+X3+dGgCXg5/e/CluK9K7qOHX
+3IkyUnZLEH5sDXGMGBzYA9AQTaB1PMTQYku6GNWYab6LFQTvpvvLcIILaFHokq8p
+D/dGVJH8uwKBgQCBOxDBPe9hTye6DGdQPJyekUrS34EwqWLd2xQJDN8sz8rUgpVY
+sKwj6PPqRs/PcbQ4ODTTeZ4BljuuEe7XyswL1xiRksjC7dF0MMlDVD1jywyVoFWe
+Q94ks+RRdzO5sXplBdYC88HOY/MIKWytxzvhUPK21LNYwUU0CFGAAw0DYQKBgQD4
+mT/qSdscoLXa9tl0fiz9vIJPtvXb3MSxgra5U6n9t9NGVMcUdGBdCZjyaaK+eGOZ
+U2mrjiNouAop++KV6x26jWvxACj7TVy6kXT4tP6WbUmWKGsaya7hfp6qOL+NfjFU
+Qn8y0+URYB4zWNbO3asFIwSJEkPMx8K9IMkMP5WF3wKBgCYiqAhPDF4WxA3fAqP7
+95px8Clrety0mwOtE/rMQRf1nKJ78oA4pr+/VXRbyghAxtD4psbmBQofX3iwnn3B
+o1DV3FLpNw004mvcKGScUcNwHQtWAtWX2nVDcxes5R2DgN+lpmWmf5Tq47p0r5ZP
+nRb92drrnf8FoBv78CxLjIu+
+-----END PRIVATE KEY-----
diff --git a/.archive/docker/nginx/ssl/localhost+2.pem b/.archive/docker/nginx/ssl/localhost+2.pem
new file mode 100644
index 00000000..58a8c808
--- /dev/null
+++ b/.archive/docker/nginx/ssl/localhost+2.pem
@@ -0,0 +1,25 @@
+-----BEGIN CERTIFICATE-----
+MIIEHjCCAoagAwIBAgIQLqhFNHvvWJKUpuypArU2CjANBgkqhkiG9w0BAQsFADBb
+MR4wHAYDVQQKExVta2NlcnQgZGV2ZWxvcG1lbnQgQ0ExGDAWBgNVBAsMD21pY2hh
+ZWxATWlrZS1QQzEfMB0GA1UEAwwWbWtjZXJ0IG1pY2hhZWxATWlrZS1QQzAeFw0y
+NTA1MTgxOTUyMDlaFw0yNzA4MTgxOTUyMDlaMEMxJzAlBgNVBAoTHm1rY2VydCBk
+ZXZlbG9wbWVudCBjZXJ0aWZpY2F0ZTEYMBYGA1UECwwPbWljaGFlbEBNaWtlLVBD
+MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAwM8EvBRkgg8A4O0F/DqR
+pF9Um0sG1Ms1zYxLWt9fQbwB9jn3BRQo+rv4qny+4CjjPN7fLu9VQRbAsWZcV9iJ
+crtvq+9rAnRgV3Cuq4kx65I07OLlemFffHibmIbwM0oo6bEUI8J8EOfO3GsbQl2Y
+Ts3nt0527c6uKZapjikddA/nL6zmcbqCiPdeG5V6RnvHbN71hIsXsK3sdAmIcz4/
+8xBd8nwqEl3k5hQVG5ph/ycHAivLjubel0dQ8qNzOBjjK5hrTu1OJ7i+nuybG2Xz
+2hFvcCrQ4xMBQyUi8tACxKYjVr21uDmmVjZCZNI3ymMMgbpzUrOtgeN9O6BfJala
+NQIDAQABo3YwdDAOBgNVHQ8BAf8EBAMCBaAwEwYDVR0lBAwwCgYIKwYBBQUHAwEw
+HwYDVR0jBBgwFoAUhhzxUvThIGRX4MSoX91Vzm1zZ9AwLAYDVR0RBCUwI4IJbG9j
+YWxob3N0hwR/AAABhxAAAAAAAAAAAAAAAAAAAAABMA0GCSqGSIb3DQEBCwUAA4IB
+gQDUFLYZPo8RrfZh/vwT15LcIce8brdVegms6DvPK9lMZX6C4sGf4+rTJCwPuqHW
+dqVZAhHdvcsyGI15xvVPT4qSh89RN1JB9uIHCk+weIzp+Rn06MMrB49m4abAvWp2
+hB8bCo80hMVIsCb3Wr9sHg7CsJItsdGz8jHYCvHpvPLR7gWhYjm1g0meglT3tZqd
+TsKDMb3Vj/vsivEueM6Oj/of8xbamVSSkqljWbRls7Ti7xqXMbmf7nl0WvG9IXg3
+5Ucv1AWJIFEeLnMM5V0nEbO3sAhbNMLXieGPBWHXOgHuvVnQyu1mBESjgc5bjwfN
+UjYBHluFkF9aYw3mGcFqAlb1FpGoMtHwTw0uGZzHzj5FY8oZix5edq/upriV6cU2
+t0tidlfhvkJNSSO4zjAPjU1wd+/QRZwY2PcB5kBxs5MzSmiMlEjTkGgHWqMWMBf1
+NPbyaxtjL69xBVonxpqD6BLJ2qLatgCs6fkZZF7AT38OFXr8Cv5vxt1rR5fs1P6X
+mI0=
+-----END CERTIFICATE-----
diff --git a/.archive/docker/nginx/vite-proxy.inc.dev b/.archive/docker/nginx/vite-proxy.inc.dev
new file mode 100644
index 00000000..991db4b7
--- /dev/null
+++ b/.archive/docker/nginx/vite-proxy.inc.dev
@@ -0,0 +1,4 @@
+location / {
+    try_files $uri $uri/ /index.php?$query_string;
+    autoindex off;
+}
diff --git a/.archive/docker/nginx/vite-proxy.inc.prod b/.archive/docker/nginx/vite-proxy.inc.prod
new file mode 100644
index 00000000..991db4b7
--- /dev/null
+++ b/.archive/docker/nginx/vite-proxy.inc.prod
@@ -0,0 +1,4 @@
+location / {
+    try_files $uri $uri/ /index.php?$query_string;
+    autoindex off;
+}
diff --git a/.archive/docker/php/Dockerfile b/.archive/docker/php/Dockerfile
new file mode 100644
index 00000000..9e97d9d9
--- /dev/null
+++ b/.archive/docker/php/Dockerfile
@@ -0,0 +1,99 @@
+# Dockerfile für PHP-FPM
+FROM php:8.4-fpm AS base
+
+# System-Abhängigkeiten: Werden selten geändert, daher ein eigener Layer
+RUN apt-get update && apt-get install -y \
+    git \
+    unzip \
+    libzip-dev \
+    zip \
+    libpng-dev \
+    libjpeg-dev \
+    libfreetype6-dev \
+    libwebp-dev \
+    libavif-dev \
+    libxpm-dev \
+    && apt-get clean \
+        && rm -rf /var/lib/apt/lists/*
+
+RUN docker-php-ext-configure gd \
+            --with-freetype \
+            --with-jpeg \
+            --with-webp \
+            --with-avif \
+            --with-xpm \
+    && docker-php-ext-install -j$(nproc) gd
+
+RUN docker-php-ext-install -j$(nproc) \
+    zip \
+    pdo \
+    pdo_mysql \
+    opcache \
+    pcntl \
+    posix \
+    shmop
+
+
+
+# Composer installieren
+RUN curl -sS https://getcomposer.org/installer | php \
+    && mv composer.phar /usr/local/bin/composer
+
+# Installiere Xdebug nur im Entwicklungsmodus
+ARG ENV=prod
+RUN if [ "$ENV" = "dev" ]; then \
+    pecl install xdebug \
+    && docker-php-ext-enable xdebug; \
+    fi
+
+WORKDIR /var/www/html
+
+# Kopiere composer.json
+COPY composer.json ./
+
+# Kopiere composer.lock falls vorhanden (robuste Lösung)
+COPY composer.loc[k] ./
+
+# Falls keine composer.lock existiert, erstelle eine leere um Layer-Caching zu ermöglichen
+RUN [ ! -f composer.lock ] && touch composer.lock || true
+
+# Remove potentially corrupted composer.lock and install dependencies
+RUN rm -f composer.lock && \
+    if [ "$ENV" = "prod" ]; then \
+        composer install --no-dev --no-scripts --no-autoloader --optimize-autoloader; \
+    else \
+        composer install --no-scripts --no-autoloader; \
+    fi
+
+# Kopiere PHP-Konfigurationen
+COPY docker/php/php.common.ini /usr/local/etc/php/php.common.ini
+COPY docker/php/php.${ENV}.ini /usr/local/etc/php/php.ini
+
+# Wenn dev, kopiere auch xdebug-Konfiguration
+RUN if [ "$ENV" = "dev" ]; then \
+    mkdir -p /usr/local/etc/php/conf.d/; \
+    fi
+COPY docker/php/xdebug.ini /usr/local/etc/php/conf.d/docker-php-ext-xdebug.ini
+
+# Kopiere den Rest des Projekts
+COPY . .
+
+# Optimiere Autoloader
+RUN composer dump-autoload --optimize
+
+# <<--- ALLE zusätzlichen System-Dateien und chmod noch als root!
+COPY docker/php/docker-entrypoint.sh /usr/local/bin/docker-entrypoint.sh
+RUN chmod +x /usr/local/bin/docker-entrypoint.sh
+
+# Danach erst den Nutzer wechseln!
+RUN groupadd -g 1000 appuser && useradd -u 1000 -g appuser -m appuser
+RUN chown -R appuser:appuser /var/www/html
+
+USER appuser
+
+RUN mkdir -p /var/www/html/cache && \
+    chown -R 1000:1000 /var/www/html/cache && \
+    chmod -R 775 /var/www/html/cache
+
+ENTRYPOINT ["/usr/local/bin/docker-entrypoint.sh"]
+CMD ["php-fpm"]
diff --git a/.archive/docker/php/docker-entrypoint.sh b/.archive/docker/php/docker-entrypoint.sh
new file mode 100644
index 00000000..db0575ff
--- /dev/null
+++ b/.archive/docker/php/docker-entrypoint.sh
@@ -0,0 +1,4 @@
+#!/bin/bash
+chown -R www-data:www-data /var/www/html/cache
+chmod -R 775 /var/www/html/cache
+exec "$@"
diff --git a/.archive/docker/php/php.common.ini b/.archive/docker/php/php.common.ini
new file mode 100644
index 00000000..55565d63
--- /dev/null
+++ b/.archive/docker/php/php.common.ini
@@ -0,0 +1,10 @@
+expose_php = Off
+
+session.cookie_secure = 1
+session.cookie_httponly = 1
+session.cookie_samesite = Lax
+
+
+date.timezone = Europe/Berlin
+
+opcache.preload=/var/www/michaelschiemer/src/preload.php
diff --git a/.archive/docker/php/php.development.ini b/.archive/docker/php/php.development.ini
new file mode 100644
index 00000000..6f8c39d8
--- /dev/null
+++ b/.archive/docker/php/php.development.ini
@@ -0,0 +1,29 @@
+; php.ini für Entwicklung
+include = php.common.ini
+
+
+[opcache]
+opcache.enable=0
+opcache.enable_cli=0
+opcache.memory_consumption=128
+opcache.max_accelerated_files=10000
+; Häufigere Validierung im Dev-Modus
+opcache.revalidate_freq=0
+; Timestamps-Validierung einschalten für Entwicklung
+opcache.validate_timestamps=1
+
+opcache.file_cache=
+realpath_cache_ttl=0
+
+opcache.interned_strings_buffer=16
+
+
+display_errors = On
+display_startup_errors = On
+error_reporting = E_ALL
+memory_limit = 512M
+upload_max_filesize = 20M
+post_max_size = 25M
+max_execution_time = 60
+
+; Xdebug-Einstellungen können auch hier hinzugefügt werden, falls gewünscht
diff --git a/.archive/docker/php/php.prod.ini b/.archive/docker/php/php.prod.ini
new file mode 100644
index 00000000..557ca72e
--- /dev/null
+++ b/.archive/docker/php/php.prod.ini
@@ -0,0 +1,31 @@
+; php.ini für Produktion
+include = php.common.ini
+
+[opcache]
+; Aktiviere OPcache
+opcache.enable=1
+; Aktiviere OPcache für CLI-Anwendungen (optional)
+opcache.enable_cli=0
+; Maximale Speichernutzung für Cache in MB
+opcache.memory_consumption=128
+; Maximale Anzahl an gecachten Dateien
+opcache.max_accelerated_files=10000
+; Wie oft wird der Cache validiert (0 = bei jedem Request, empfohlen für Entwicklung)
+; In Produktion höher setzen für bessere Performance
+opcache.revalidate_freq=60
+; Cache-Zeitstempel prüfen (0 für Produktionsumgebungen)
+opcache.validate_timestamps=0
+; Performance-Optimierungen
+opcache.interned_strings_buffer=16
+; JIT (Just-In-Time Compilation) - Optional für PHP 8.0+
+opcache.jit_buffer_size=100M
+opcache.jit=1255
+
+
+display_errors = Off
+display_startup_errors = Off
+error_reporting = E_ALL & ~E_DEPRECATED & ~E_STRICT
+memory_limit = 256M
+upload_max_filesize = 10M
+post_max_size = 12M
+max_execution_time = 30
diff --git a/.archive/docker/php/xdebug.ini b/.archive/docker/php/xdebug.ini
new file mode 100644
index 00000000..8852ee79
--- /dev/null
+++ b/.archive/docker/php/xdebug.ini
@@ -0,0 +1,7 @@
+; Xdebug 3 Konfiguration
+xdebug.mode=${XDEBUG_MODE:-off}
+xdebug.client_host=host.docker.internal
+xdebug.client_port=9003
+xdebug.start_with_request=yes
+xdebug.log=/var/log/xdebug.log
+xdebug.idekey=PHPSTORM
diff --git a/.archive/docker/redis/redis.conf b/.archive/docker/redis/redis.conf
new file mode 100644
index 00000000..1af50745
--- /dev/null
+++ b/.archive/docker/redis/redis.conf
@@ -0,0 +1,7 @@
+bind 0.0.0.0
+#protected-mode yes
+dir /data
+save 900 1
+save 300 10
+save 60 10000
+appendonly yes
diff --git a/.archive/docker/worker/Dockerfile b/.archive/docker/worker/Dockerfile
new file mode 100644
index 00000000..aedf6c5b
--- /dev/null
+++ b/.archive/docker/worker/Dockerfile
@@ -0,0 +1,115 @@
+FROM php:8.4.8-cli
+
+# Install system dependencies including libraries for GD and other extensions
+RUN apt-get update && apt-get install -y \
+    git \
+    curl \
+    libpng-dev \
+    libjpeg62-turbo-dev \
+    libfreetype6-dev \
+    libonig-dev \
+    libxml2-dev \
+    libzip-dev \
+    libicu-dev \
+    zip \
+    unzip \
+    procps \
+    && rm -rf /var/lib/apt/lists/* \
+    && apt-get clean
+
+# Configure GD extension with JPEG and FreeType support
+RUN docker-php-ext-configure gd --with-freetype --with-jpeg
+
+# Install PHP extensions for worker functionality and web features
+RUN docker-php-ext-install -j$(nproc) \
+    pdo_mysql \
+    mbstring \
+    exif \
+    pcntl \
+    posix \
+    sockets \
+    gd \
+    zip \
+    intl \
+    opcache
+
+# Install Composer
+COPY --from=composer:latest /usr/bin/composer /usr/bin/composer
+
+# Set working directory
+WORKDIR /var/www/html
+
+# Copy application files
+COPY . .
+
+# Install dependencies (composer.lock wird automatisch erstellt falls nicht vorhanden)
+# Check if composer.json exists, if not create a minimal one
+RUN if [ ! -f composer.json ]; then \
+        echo "Creating minimal composer.json..."; \
+        echo '{\
+    "name": "worker/app",\
+    "description": "Worker application",\
+    "type": "project",\
+    "require": {\
+        "php": ">=8.4"\
+    },\
+    "autoload": {\
+        "psr-4": {\
+            "App\\\\": "src/"\
+        }\
+    },\
+    "minimum-stability": "stable",\
+    "prefer-stable": true\
+}' > composer.json; \
+    fi && \
+    composer install \
+        --no-dev \
+        --optimize-autoloader \
+        --no-interaction || echo "Composer install skipped or failed - continuing without dependencies"
+
+# Create startup script for permission fixing
+RUN echo '#!/bin/bash\n\
+set -e\n\
+\n\
+echo "🔧 Fixing permissions..."\n\
+\n\
+# Create directories if they do not exist\n\
+mkdir -p /var/www/html/src/Framework/CommandBus/storage/queue\n\
+mkdir -p /var/www/html/storage/logs\n\
+mkdir -p /var/www/html/storage/cache\n\
+\n\
+# Fix permissions on mounted volumes\n\
+chown -R www-data:www-data /var/www/html/storage || true\n\
+chown -R www-data:www-data /var/www/html/src/Framework/CommandBus/storage || true\n\
+chmod -R 775 /var/www/html/storage || true\n\
+chmod -R 775 /var/www/html/src/Framework/CommandBus/storage || true\n\
+\n\
+echo "✅ Permissions fixed"\n\
+echo "🚀 Starting worker..."\n\
+\n\
+# Switch to www-data user and run the worker\n\
+exec gosu www-data php /var/www/html/worker.php\n' > /usr/local/bin/start-worker.sh \
+    && chmod +x /usr/local/bin/start-worker.sh
+
+# Install gosu for better user switching (alternative to su-exec for Debian)
+RUN apt-get update && apt-get install -y gosu && rm -rf /var/lib/apt/lists/*
+
+# Create necessary directories and set permissions
+RUN mkdir -p \
+    /var/www/html/src/Framework/CommandBus/storage/queue \
+    /var/www/html/storage/logs \
+    /var/www/html/storage/cache \
+    && chown -R www-data:www-data /var/www/html/storage \
+    && chmod -R 775 /var/www/html/storage
+
+# Create queue storage directory with proper permissions
+RUN mkdir -p /var/www/html/src/Framework/CommandBus/storage \
+    && chown -R www-data:www-data /var/www/html/src/Framework/CommandBus/storage \
+    && chmod -R 775 /var/www/html/src/Framework/CommandBus/storage
+
+# Health check for the worker
+HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 \
+    CMD ps aux | grep -v grep | grep "worker.php" || exit 1
+
+# Use startup script instead of direct PHP command
+CMD ["/usr/local/bin/start-worker.sh"]
diff --git a/.archive/dockerBackup/nginx/Dockerfile b/.archive/dockerBackup/nginx/Dockerfile
new file mode 100644
index 00000000..0705b114
--- /dev/null
+++ b/.archive/dockerBackup/nginx/Dockerfile
@@ -0,0 +1,73 @@
+FROM macbre/nginx-http3
+
+# Zurück zu root wechseln
+USER root
+
+# Entferne Default-Site
+RUN rm -f /etc/nginx/conf.d/default.conf || true
+
+# Verzeichnisse erstellen
+RUN mkdir -p /var/cache/nginx /var/log/nginx /var/www/ssl && \
+    chmod 755 /var/cache/nginx /var/log/nginx /var/www/ssl
+
+# Konfigurationen kopieren
+COPY ./nginx.conf /etc/nginx/nginx.conf
+COPY ./default.conf /etc/nginx/conf.d/default.conf
+COPY ./ssl/ /var/www/ssl/
+
+# Entry-Script kopieren
+COPY ./docker-entrypoint.sh /usr/local/bin/docker-entrypoint.sh
+RUN chmod +x /usr/local/bin/docker-entrypoint.sh
+
+# su-exec und netcat installieren
+RUN apk add --no-cache su-exec netcat-openbsd
+
+# Berechtigungen für stdout/stderr anpassen
+RUN chmod a+rw /dev/stdout /dev/stderr
+
+# Ordner-Berechtigungen für den nginx-User setzen
+RUN chown -R nginx:nginx /var/cache/nginx /var/log/nginx /var/www/ssl
+
+EXPOSE 80 443
+
+ENTRYPOINT ["/usr/local/bin/docker-entrypoint.sh"]
+#CMD ["nginx", "-g", "daemon off;"]
+
+
+
+
+
+## Standard-Konfiguration entfernen
+#RUN rm -f /etc/nginx/conf.d/default.conf
+#
+## Verzeichnisse erstellen mit korrekten Berechtigungen
+#RUN mkdir -p /var/cache/nginx /var/log/nginx /etc/nginx/template && \
+#    chmod -R 777 /var/cache/nginx /var/log/nginx
+#
+## Kopiere die Template-Konfiguration
+#COPY ./nginx.conf /etc/nginx/nginx.conf
+#COPY ./default.conf /etc/nginx/conf.d/default.conf
+#
+## Kopiert config Include
+#COPY ./vite-proxy.inc.dev /etc/nginx/vite-proxy.inc
+#
+## Kopiere die SSL-Zertifikate
+#COPY ./ssl/ /etc/nginx/ssl/
+#
+## Startup-Skript zum Ersetzen der Variablen
+#COPY ./docker-entrypoint.sh /
+#RUN chmod +x /docker-entrypoint.sh
+#
+##Install Netcat
+#RUN apk add --no-cache netcat-openbsd
+#
+#
+## Als user www-data laufen lassen
+#RUN addgroup -g 1000 www && adduser -D -G www -u 1000 www-data \
+# && chown -R www-data:www /var/cache/nginx /var/log/nginx /etc/nginx
+#USER www-data
+#
+#EXPOSE 80 443
+#
+#ENTRYPOINT ["/docker-entrypoint.sh"]
+#CMD ["nginx", "-g", "daemon off;"]
diff --git a/.archive/dockerBackup/nginx/default.conf b/.archive/dockerBackup/nginx/default.conf
new file mode 100644
index 00000000..270ba3fe
--- /dev/null
+++ b/.archive/dockerBackup/nginx/default.conf
@@ -0,0 +1,252 @@
+# FastCGI-Cache-Einstellungen
+fastcgi_cache_path /var/cache/nginx levels=1:2 keys_zone=PHPCACHE:100m inactive=60m;
+fastcgi_cache_key "$scheme$request_method$host$request_uri";
+fastcgi_cache_use_stale error timeout invalid_header http_500;
+fastcgi_ignore_headers Cache-Control Expires Set-Cookie;
+
+# Hardcoded Umgebungsmodus basierend auf Template-Ersetzung
+map $http_host $env_mode {
+    default "${APP_ENV}";
+}
+
+# Dynamische Cache-Kontrolle basierend auf Umgebungsvariable
+map $env_mode $should_skip_cache {
+    default       0;       # Standard (Produktion): Cache aktivieren
+    development   1;       # Entwicklung: Cache deaktivieren
+    testing       1;       # Testing: Cache deaktivieren
+}
+
+# Skip-Cache für Sessions und basierend auf Umgebung
+map $http_cookie$should_skip_cache $skip_cache {
+    "~ms_context"  1;       # Sessions nie cachen
+    "~1$"           1;       # Cache überspringen, wenn should_skip_cache = 1
+    default       0;       # Ansonsten cachen
+}
+
+map $host $block_health {
+    default 1;          # Blockiere alles
+    localhost 0;        # Erlaube nur Host "localhost"
+}
+
+upstream php-upstream {
+    server php:9000;  # „php“ ist durch Network-Alias immer erreichbar
+}
+
+server {
+    listen 80;
+    server_name localhost;
+    return 301 https://$host$request_uri;
+}
+
+server {
+    # Korrigierte HTTP/2 Syntax
+    listen 443 ssl;
+    listen 443 quic reuseport; # QUIC für HTTP/3
+
+    http2 on;  # Neue Syntax für HTTP/2
+    server_name localhost;
+
+    #ssl_certificate /etc/nginx/ssl/localhost+2.pem;
+    #ssl_certificate_key /etc/nginx/ssl/localhost+2-key.pem;
+    #ssl_certificate /etc/nginx/ssl/fullchain.pem;
+    #ssl_certificate_key /etc/nginx/ssl/privkey.pem;
+
+    ssl_certificate /var/www/ssl/fullchain.pem;
+    ssl_certificate_key /var/www/ssl/privkey.pem;
+
+
+    add_header Alt-Svc 'h3=":443"'; # Für HTTP/3 Unterstützung
+    #add_header QUIC-Status $quic;
+
+
+    ssl_protocols TLSv1.3 TLSv1.2;
+    ssl_prefer_server_ciphers on;
+    ssl_ciphers ECDHE-RSA-AES256-GCM-SHA512:DHE-RSA-AES256-GCM-SHA512:ECDHE-RSA-AES256-GCM-SHA384:DHE-RSA-AES256-GCM-SHA384;
+
+    # Verbesserte SSL-Konfiguration
+    ssl_session_timeout 1d;
+    ssl_session_cache shared:SSL:10m;
+    ssl_session_tickets off;
+
+    # OCSP Stapling (auskommentiert, wenn Zertifikate fehlen)
+    # ssl_stapling on;
+    # ssl_stapling_verify on;
+    resolver 1.1.1.1 1.0.0.1 valid=300s;
+    resolver_timeout 5s;
+
+    root /var/www/html/public;
+    index index.php index.html;
+
+    location / {
+        try_files $uri $uri/ /index.php?$query_string;
+        autoindex off;
+    }
+
+    # Debug-Header für die Entwicklung
+    add_header X-Environment $env_mode always;
+
+    # Sicherheits-Header
+    add_header X-Content-Type-Options nosniff;
+    add_header X-Frame-Options DENY always;
+    add_header X-XSS-Protection "1; mode=block" always;
+    add_header Referrer-Policy "no-referrer-when-downgrade" always;
+    add_header Permissions-Policy "geolocation=(), microphone=()" always;
+    add_header Strict-Transport-Security "max-age=63072000; includeSubDomains" always;
+
+    # CSP Header
+    add_header Content-Security-Policy "default-src 'self'; script-src 'self'; style-src 'self'; object-src 'none'" always;
+
+    # Buffer-Größen anpassen
+    client_body_buffer_size 10K;
+    client_header_buffer_size 1k;
+    client_max_body_size 10m;
+    large_client_header_buffers 2 1k;
+
+    # Verbesserte Gzip-Kompression
+    gzip on;
+    gzip_vary on;
+    gzip_proxied any;
+    gzip_comp_level 6;
+    gzip_buffers 16 8k;
+    gzip_http_version 1.1;
+    gzip_min_length 256;
+    gzip_types
+        application/atom+xml
+        application/javascript
+        application/json
+        application/ld+json
+        application/manifest+json
+        application/rss+xml
+        application/vnd.geo+json
+        application/vnd.ms-fontobject
+        application/x-font-ttf
+        application/x-web-app-manifest+json
+        application/xhtml+xml
+        application/xml
+        font/opentype
+        image/bmp
+        image/svg+xml
+        image/x-icon
+        text/cache-manifest
+        text/css
+        text/plain
+        text/vcard
+        text/vnd.rim.location.xloc
+        text/vtt
+        text/x-component
+        text/x-cross-domain-policy;
+
+    # Logs
+    #access_log /var/log/nginx/access.log combined;
+    #error_log /var/log/nginx/error.log error;
+    access_log /dev/stdout;
+    error_log /dev/stderr warn;
+
+    # läuft aktuell oben über dynamischen include!
+    #location / {
+    #    try_files $uri $uri/ /index.php?$query_string;
+    #    autoindex off;
+    #}
+
+    # Service-Worker explizit erlauben (auch im Production-Server ungefährlich!)
+    location = /sw.js {
+        # je nach Build-Ordner anpassen!
+        alias /var/www/html/public/sw.js;
+        add_header Cache-Control "no-cache, must-revalidate";
+    }
+
+    # Caching Header für statische Dateien
+    #location ~* \.(jpg|jpeg|png|gif|ico|svg|woff|woff2|ttf|eot)$ {
+    #    expires 1y;
+    #    add_header Cache-Control "public, immutable, max-age=31536000";
+    #}
+
+    location ~* \.(css|js)$ {
+        expires 1w;
+        add_header Cache-Control "public, max-age=604800";
+    }
+
+#     location ~* \.(json|xml)$ {
+#         expires 1d;
+#         add_header Cache-Control "public, max-age=86400";
+#     }
+
+    location ~ \.php$ {
+        try_files $uri =404;
+        include fastcgi_params;
+        fastcgi_pass php-upstream;
+        fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
+        fastcgi_param PATH_INFO $fastcgi_path_info;
+        fastcgi_split_path_info ^(.+\.php)(/.+)$;
+
+        # Wichtig: APP_ENV an PHP weitergeben
+        fastcgi_param APP_ENV $env_mode;
+
+        # Timeout-Einstellungen
+        fastcgi_read_timeout 60s;
+        fastcgi_connect_timeout 60s;
+        fastcgi_send_timeout 60s;
+
+        # Caching-Einstellungen
+        fastcgi_buffer_size 128k;
+        fastcgi_buffers 4 256k;
+        fastcgi_busy_buffers_size 256k;
+
+        # Cache FastCGI-Antworten
+        fastcgi_cache_bypass $skip_cache;
+        fastcgi_no_cache $skip_cache;
+
+        fastcgi_cache PHPCACHE;
+        fastcgi_cache_valid 200 60m;
+
+        # Debug-Header hinzufügen
+        add_header X-Cache-Status $upstream_cache_status;
+        add_header X-Cache-Environment $env_mode;
+        add_header X-Cache-Skip $skip_cache;
+
+        # Für bessere Performance
+        fastcgi_keep_conn on;
+    }
+
+    # Sicherheitseinstellungen
+    location ~ /\.(?!well-known).* {
+        deny all;
+    }
+
+    server_tokens off;
+    limit_req zone=mylimit burst=20 nodelay;
+
+    location ~* /(?:uploads|files)/.*\.php$ {
+        deny all;
+    }
+
+    # Healthcheck-Endpunkt
+    location = /ping {
+        access_log off;
+        add_header Content-Type text/plain;
+        return 200 'pong';
+    }
+
+    location = /health {
+        if ($block_health) {
+            return 404;
+        }
+
+        try_files /health.php =404;
+
+        allow 127.0.0.1;        # Lokal erlaubt (Ansible, Docker, Monitoring intern)
+        allow ::1;
+        allow 192.168.0.0/16;   # Optional: internes Netz (z.B. für internen Loadbalancer)
+        deny all;
+        error_page 403 =404;
+    }
+
+
+    error_page 404 /errors/404.html;
+    error_page 403 /errors/403.html;
+    error_page 500 502 503 504 /errors/50x.html;
+
+    location /errors/ {
+        internal; # Verhindert direkten Zugriff
+    }
+}
diff --git a/.archive/dockerBackup/nginx/docker-entrypoint.sh b/.archive/dockerBackup/nginx/docker-entrypoint.sh
new file mode 100644
index 00000000..4abeec50
--- /dev/null
+++ b/.archive/dockerBackup/nginx/docker-entrypoint.sh
@@ -0,0 +1,31 @@
+#!/bin/sh
+set -e
+
+until nc -z -w 2 php 9000; do
+  echo "Warte auf PHP-FPM..."
+  sleep 1
+done
+
+# Optional: eigene Umgebungsvariable mit Default setzen
+export APP_ENV="${APP_ENV:-production}"
+
+echo "Starte Nginx mit APP_ENV=$APP_ENV"
+
+# Ersetze Platzhalter in temporäre Datei
+envsubst '${APP_ENV}' < /etc/nginx/conf.d/default.conf > /tmp/default.conf
+
+# Ersetzte Originalkonfiguration
+cp /tmp/default.conf /etc/nginx/conf.d/default.conf
+
+# WICHTIG: Rechte für stdout/stderr anpassen
+chmod a+rw /dev/stdout /dev/stderr
+
+# Nginx-Ordner Rechte anpassen
+mkdir -p /var/cache/nginx /var/log/nginx
+chown -R nginx:nginx /var/cache/nginx /var/log/nginx
+
+# Stelle sicher, dass das SSL-Verzeichnis existiert
+mkdir -p /var/www/ssl
+
+# Jetzt kann nginx sicher starten
+exec nginx -g 'daemon off;'
diff --git a/.archive/dockerBackup/nginx/nginx.conf b/.archive/dockerBackup/nginx/nginx.conf
new file mode 100644
index 00000000..631dc1df
--- /dev/null
+++ b/.archive/dockerBackup/nginx/nginx.conf
@@ -0,0 +1,39 @@
+worker_processes auto;
+pid /tmp/nginx.pid;
+
+events {
+    worker_connections 1024;
+}
+
+http {
+    include /etc/nginx/mime.types;
+    default_type application/octet-stream;
+
+    server_tokens off;
+
+    # Rate-Limiting für besseren DDoS-Schutz
+    limit_req_zone $binary_remote_addr zone=mylimit:10m rate=10r/s;
+
+    # Logging-Einstellungen
+    log_format main '$remote_addr - $remote_user [$time_local] "$request" '
+                    '$status $body_bytes_sent "$http_referer" '
+                    '"$http_user_agent" "$http_x_forwarded_for"';
+
+    #access_log /var/log/nginx/access.log main;
+    #error_log /var/log/nginx/error.log warn;
+    access_log /dev/stdout;
+    error_log /dev/stderr warn;
+
+    sendfile on;
+    tcp_nopush on;
+    tcp_nodelay on;
+    keepalive_timeout 65;
+    types_hash_max_size 2048;
+
+    # TLS-Einstellungen
+    #ssl_session_cache shared:SSL:10m;
+    #ssl_session_timeout 10m;
+
+    # Include server configs
+    include /etc/nginx/conf.d/*.conf;
+}
diff --git a/.archive/dockerBackup/nginx/ssl/localhost+2-key.pem b/.archive/dockerBackup/nginx/ssl/localhost+2-key.pem
new file mode 100644
index 00000000..ed2534ce
--- /dev/null
+++ b/.archive/dockerBackup/nginx/ssl/localhost+2-key.pem
@@ -0,0 +1,28 @@
+-----BEGIN PRIVATE KEY-----
+MIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQDAzwS8FGSCDwDg
+7QX8OpGkX1SbSwbUyzXNjEta319BvAH2OfcFFCj6u/iqfL7gKOM83t8u71VBFsCx
+ZlxX2Ilyu2+r72sCdGBXcK6riTHrkjTs4uV6YV98eJuYhvAzSijpsRQjwnwQ587c
+axtCXZhOzee3Tnbtzq4plqmOKR10D+cvrOZxuoKI914blXpGe8ds3vWEixewrex0
+CYhzPj/zEF3yfCoSXeTmFBUbmmH/JwcCK8uO5t6XR1Dyo3M4GOMrmGtO7U4nuL6e
+7JsbZfPaEW9wKtDjEwFDJSLy0ALEpiNWvbW4OaZWNkJk0jfKYwyBunNSs62B4307
+oF8lqVo1AgMBAAECggEAbPlU0ryv5fZ256nvlRTBVmbvGep4zPKh0TA3MwBHBY8u
+iK1QWVWAp95v+GQTOfzCGphZCl0JEYW7mUiibqAbZ3Za8pGaKMP/48vzXU5ooZ18
+PlsrmlTItEAyqS2zOznyD8se9+snViK+f0QmHwdpWzjze15kx5nmQ+k8ofXJCNwq
+q3dJIMI/WNuc0e/mMHYjZBsIwuoUi6YJHCE6RkWhGcnvlyXdKUV73/n8Loy6DUtW
+VmshXag7+GfbVZIesMCjfnJ0gr9OG+XrFl6AcggzFA1ZHRoQliraVYGB2duQlIpW
+o1wJMhFSGFPZxvl67hwXHJeo7ghHHfqNYXS1OuhV7QKBgQDBrvyzLtav51LzqOUY
+2HPvaH86arbARc4Fy6ZJ0TaSlmKQ5GzRG0lG2CR03oZz+OcMV/BU8xUMM7CX0zUq
+9RAmbE7rvXYOvqTe8pcdHeKKflzsr5p0HNROaeZdpMu8xoK1KLelAo6UCEBUGEny
+oMtQWapuYvmdlHR2el2ICRGNzwKBgQD+1/iM1LcF9CYvEc8Sly9XuoRsdUCxavQa
+sssv7eG5kkL8HroNs1pGZU8lNuZaT1V0ekWVOFk+X3+dGgCXg5/e/CluK9K7qOHX
+3IkyUnZLEH5sDXGMGBzYA9AQTaB1PMTQYku6GNWYab6LFQTvpvvLcIILaFHokq8p
+D/dGVJH8uwKBgQCBOxDBPe9hTye6DGdQPJyekUrS34EwqWLd2xQJDN8sz8rUgpVY
+sKwj6PPqRs/PcbQ4ODTTeZ4BljuuEe7XyswL1xiRksjC7dF0MMlDVD1jywyVoFWe
+Q94ks+RRdzO5sXplBdYC88HOY/MIKWytxzvhUPK21LNYwUU0CFGAAw0DYQKBgQD4
+mT/qSdscoLXa9tl0fiz9vIJPtvXb3MSxgra5U6n9t9NGVMcUdGBdCZjyaaK+eGOZ
+U2mrjiNouAop++KV6x26jWvxACj7TVy6kXT4tP6WbUmWKGsaya7hfp6qOL+NfjFU
+Qn8y0+URYB4zWNbO3asFIwSJEkPMx8K9IMkMP5WF3wKBgCYiqAhPDF4WxA3fAqP7
+95px8Clrety0mwOtE/rMQRf1nKJ78oA4pr+/VXRbyghAxtD4psbmBQofX3iwnn3B
+o1DV3FLpNw004mvcKGScUcNwHQtWAtWX2nVDcxes5R2DgN+lpmWmf5Tq47p0r5ZP
+nRb92drrnf8FoBv78CxLjIu+
+-----END PRIVATE KEY-----
diff --git a/.archive/dockerBackup/nginx/ssl/localhost+2.pem b/.archive/dockerBackup/nginx/ssl/localhost+2.pem
new file mode 100644
index 00000000..58a8c808
--- /dev/null
+++ b/.archive/dockerBackup/nginx/ssl/localhost+2.pem
@@ -0,0 +1,25 @@
+-----BEGIN CERTIFICATE-----
+MIIEHjCCAoagAwIBAgIQLqhFNHvvWJKUpuypArU2CjANBgkqhkiG9w0BAQsFADBb
+MR4wHAYDVQQKExVta2NlcnQgZGV2ZWxvcG1lbnQgQ0ExGDAWBgNVBAsMD21pY2hh
+ZWxATWlrZS1QQzEfMB0GA1UEAwwWbWtjZXJ0IG1pY2hhZWxATWlrZS1QQzAeFw0y
+NTA1MTgxOTUyMDlaFw0yNzA4MTgxOTUyMDlaMEMxJzAlBgNVBAoTHm1rY2VydCBk
+ZXZlbG9wbWVudCBjZXJ0aWZpY2F0ZTEYMBYGA1UECwwPbWljaGFlbEBNaWtlLVBD
+MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAwM8EvBRkgg8A4O0F/DqR
+pF9Um0sG1Ms1zYxLWt9fQbwB9jn3BRQo+rv4qny+4CjjPN7fLu9VQRbAsWZcV9iJ
+crtvq+9rAnRgV3Cuq4kx65I07OLlemFffHibmIbwM0oo6bEUI8J8EOfO3GsbQl2Y
+Ts3nt0527c6uKZapjikddA/nL6zmcbqCiPdeG5V6RnvHbN71hIsXsK3sdAmIcz4/
+8xBd8nwqEl3k5hQVG5ph/ycHAivLjubel0dQ8qNzOBjjK5hrTu1OJ7i+nuybG2Xz
+2hFvcCrQ4xMBQyUi8tACxKYjVr21uDmmVjZCZNI3ymMMgbpzUrOtgeN9O6BfJala
+NQIDAQABo3YwdDAOBgNVHQ8BAf8EBAMCBaAwEwYDVR0lBAwwCgYIKwYBBQUHAwEw
+HwYDVR0jBBgwFoAUhhzxUvThIGRX4MSoX91Vzm1zZ9AwLAYDVR0RBCUwI4IJbG9j
+YWxob3N0hwR/AAABhxAAAAAAAAAAAAAAAAAAAAABMA0GCSqGSIb3DQEBCwUAA4IB
+gQDUFLYZPo8RrfZh/vwT15LcIce8brdVegms6DvPK9lMZX6C4sGf4+rTJCwPuqHW
+dqVZAhHdvcsyGI15xvVPT4qSh89RN1JB9uIHCk+weIzp+Rn06MMrB49m4abAvWp2
+hB8bCo80hMVIsCb3Wr9sHg7CsJItsdGz8jHYCvHpvPLR7gWhYjm1g0meglT3tZqd
+TsKDMb3Vj/vsivEueM6Oj/of8xbamVSSkqljWbRls7Ti7xqXMbmf7nl0WvG9IXg3
+5Ucv1AWJIFEeLnMM5V0nEbO3sAhbNMLXieGPBWHXOgHuvVnQyu1mBESjgc5bjwfN
+UjYBHluFkF9aYw3mGcFqAlb1FpGoMtHwTw0uGZzHzj5FY8oZix5edq/upriV6cU2
+t0tidlfhvkJNSSO4zjAPjU1wd+/QRZwY2PcB5kBxs5MzSmiMlEjTkGgHWqMWMBf1
+NPbyaxtjL69xBVonxpqD6BLJ2qLatgCs6fkZZF7AT38OFXr8Cv5vxt1rR5fs1P6X
+mI0=
+-----END CERTIFICATE-----
diff --git a/.archive/dockerBackup/nginx/vite-proxy.inc.dev b/.archive/dockerBackup/nginx/vite-proxy.inc.dev
new file mode 100644
index 00000000..991db4b7
--- /dev/null
+++ b/.archive/dockerBackup/nginx/vite-proxy.inc.dev
@@ -0,0 +1,4 @@
+location / {
+    try_files $uri $uri/ /index.php?$query_string;
+    autoindex off;
+}
diff --git a/.archive/dockerBackup/nginx/vite-proxy.inc.prod b/.archive/dockerBackup/nginx/vite-proxy.inc.prod
new file mode 100644
index 00000000..991db4b7
--- /dev/null
+++ b/.archive/dockerBackup/nginx/vite-proxy.inc.prod
@@ -0,0 +1,4 @@
+location / {
+    try_files $uri $uri/ /index.php?$query_string;
+    autoindex off;
+}
diff --git a/.archive/dockerBackup/php/Dockerfile b/.archive/dockerBackup/php/Dockerfile
new file mode 100644
index 00000000..a74a883b
--- /dev/null
+++ b/.archive/dockerBackup/php/Dockerfile
@@ -0,0 +1,98 @@
+# Dockerfile für PHP-FPM
+FROM php:8.4-fpm AS base
+
+# System-Abhängigkeiten: Werden selten geändert, daher ein eigener Layer
+RUN apt-get update && apt-get install -y \
+    git \
+    unzip \
+    libzip-dev \
+    zip \
+    libpng-dev \
+    libjpeg-dev \
+    libfreetype6-dev \
+    libwebp-dev \
+    libavif-dev \
+    libxpm-dev \
+    && apt-get clean \
+        && rm -rf /var/lib/apt/lists/*
+
+RUN docker-php-ext-configure gd \
+            --with-freetype \
+            --with-jpeg \
+            --with-webp \
+            --with-avif \
+            --with-xpm \
+    && docker-php-ext-install -j$(nproc) gd
+
+RUN docker-php-ext-install -j$(nproc) \
+    zip \
+    pdo \
+    pdo_mysql \
+    opcache \
+    pcntl \
+    posix \
+    shmop
+
+
+
+# Composer installieren
+RUN curl -sS https://getcomposer.org/installer | php \
+    && mv composer.phar /usr/local/bin/composer
+
+# Installiere Xdebug nur im Entwicklungsmodus
+ARG ENV=prod
+RUN if [ "$ENV" = "dev" ]; then \
+    pecl install xdebug \
+    && docker-php-ext-enable xdebug; \
+    fi
+
+WORKDIR /var/www/html
+
+# Kopiere composer.json
+COPY composer.json ./
+
+# Kopiere composer.lock falls vorhanden (robuste Lösung)
+COPY composer.loc[k] ./
+
+# Falls keine composer.lock existiert, erstelle eine leere um Layer-Caching zu ermöglichen
+RUN [ ! -f composer.lock ] && touch composer.lock || true
+
+# Installiere Abhängigkeiten - variiert je nach Umgebung
+RUN if [ "$ENV" = "prod" ]; then \
+    composer install --no-dev --no-scripts --no-autoloader --optimize-autoloader; \
+    else \
+    composer install --no-scripts --no-autoloader; \
+    fi
+
+# Kopiere PHP-Konfigurationen
+COPY docker/php/php.common.ini /usr/local/etc/php/php.common.ini
+COPY docker/php/php.${ENV}.ini /usr/local/etc/php/php.ini
+
+# Wenn dev, kopiere auch xdebug-Konfiguration
+RUN if [ "$ENV" = "dev" ]; then \
+    mkdir -p /usr/local/etc/php/conf.d/; \
+    fi
+COPY docker/php/xdebug.ini /usr/local/etc/php/conf.d/docker-php-ext-xdebug.ini
+
+# Kopiere den Rest des Projekts
+COPY . .
+
+# Optimiere Autoloader
+RUN composer dump-autoload --optimize
+
+# <<--- ALLE zusätzlichen System-Dateien und chmod noch als root!
+COPY docker/php/docker-entrypoint.sh /usr/local/bin/docker-entrypoint.sh
+RUN chmod +x /usr/local/bin/docker-entrypoint.sh
+
+# Danach erst den Nutzer wechseln!
+RUN groupadd -g 1000 appuser && useradd -u 1000 -g appuser -m appuser
+RUN chown -R appuser:appuser /var/www/html
+
+USER appuser
+
+RUN mkdir -p /var/www/html/cache && \
+    chown -R 1000:1000 /var/www/html/cache && \
+    chmod -R 775 /var/www/html/cache
+
+ENTRYPOINT ["/usr/local/bin/docker-entrypoint.sh"]
+CMD ["php-fpm"]
diff --git a/.archive/dockerBackup/php/docker-entrypoint.sh b/.archive/dockerBackup/php/docker-entrypoint.sh
new file mode 100644
index 00000000..db0575ff
--- /dev/null
+++ b/.archive/dockerBackup/php/docker-entrypoint.sh
@@ -0,0 +1,4 @@
+#!/bin/bash
+chown -R www-data:www-data /var/www/html/cache
+chmod -R 775 /var/www/html/cache
+exec "$@"
diff --git a/.archive/dockerBackup/php/php.common.ini b/.archive/dockerBackup/php/php.common.ini
new file mode 100644
index 00000000..55565d63
--- /dev/null
+++ b/.archive/dockerBackup/php/php.common.ini
@@ -0,0 +1,10 @@
+expose_php = Off
+
+session.cookie_secure = 1
+session.cookie_httponly = 1
+session.cookie_samesite = Lax
+
+
+date.timezone = Europe/Berlin
+
+opcache.preload=/var/www/michaelschiemer/src/preload.php
diff --git a/.archive/dockerBackup/php/php.development.ini b/.archive/dockerBackup/php/php.development.ini
new file mode 100644
index 00000000..6f8c39d8
--- /dev/null
+++ b/.archive/dockerBackup/php/php.development.ini
@@ -0,0 +1,29 @@
+; php.ini für Entwicklung
+include = php.common.ini
+
+
+[opcache]
+opcache.enable=0
+opcache.enable_cli=0
+opcache.memory_consumption=128
+opcache.max_accelerated_files=10000
+; Häufigere Validierung im Dev-Modus
+opcache.revalidate_freq=0
+; Timestamps-Validierung einschalten für Entwicklung
+opcache.validate_timestamps=1
+
+opcache.file_cache=
+realpath_cache_ttl=0
+
+opcache.interned_strings_buffer=16
+
+
+display_errors = On
+display_startup_errors = On
+error_reporting = E_ALL
+memory_limit = 512M
+upload_max_filesize = 20M
+post_max_size = 25M
+max_execution_time = 60
+
+; Xdebug-Einstellungen können auch hier hinzugefügt werden, falls gewünscht
diff --git a/.archive/dockerBackup/php/php.prod.ini b/.archive/dockerBackup/php/php.prod.ini
new file mode 100644
index 00000000..557ca72e
--- /dev/null
+++ b/.archive/dockerBackup/php/php.prod.ini
@@ -0,0 +1,31 @@
+; php.ini für Produktion
+include = php.common.ini
+
+[opcache]
+; Aktiviere OPcache
+opcache.enable=1
+; Aktiviere OPcache für CLI-Anwendungen (optional)
+opcache.enable_cli=0
+; Maximale Speichernutzung für Cache in MB
+opcache.memory_consumption=128
+; Maximale Anzahl an gecachten Dateien
+opcache.max_accelerated_files=10000
+; Wie oft wird der Cache validiert (0 = bei jedem Request, empfohlen für Entwicklung)
+; In Produktion höher setzen für bessere Performance
+opcache.revalidate_freq=60
+; Cache-Zeitstempel prüfen (0 für Produktionsumgebungen)
+opcache.validate_timestamps=0
+; Performance-Optimierungen
+opcache.interned_strings_buffer=16
+; JIT (Just-In-Time Compilation) - Optional für PHP 8.0+
+opcache.jit_buffer_size=100M
+opcache.jit=1255
+
+
+display_errors = Off
+display_startup_errors = Off
+error_reporting = E_ALL & ~E_DEPRECATED & ~E_STRICT
+memory_limit = 256M
+upload_max_filesize = 10M
+post_max_size = 12M
+max_execution_time = 30
diff --git a/.archive/dockerBackup/php/xdebug.ini b/.archive/dockerBackup/php/xdebug.ini
new file mode 100644
index 00000000..8852ee79
--- /dev/null
+++ b/.archive/dockerBackup/php/xdebug.ini
@@ -0,0 +1,7 @@
+; Xdebug 3 Konfiguration
+xdebug.mode=${XDEBUG_MODE:-off}
+xdebug.client_host=host.docker.internal
+xdebug.client_port=9003
+xdebug.start_with_request=yes
+xdebug.log=/var/log/xdebug.log
+xdebug.idekey=PHPSTORM
diff --git a/.bashrc b/.bashrc
new file mode 100644
index 00000000..4c021b9f
--- /dev/null
+++ b/.bashrc
@@ -0,0 +1 @@
+alias appconsole='docker exec -it php php console.php'
diff --git a/.dockerignore b/.dockerignore
index 2e30e92e..72dda794 100644
--- a/.dockerignore
+++ b/.dockerignore
@@ -1,8 +1,115 @@
+# Exclude everything first
+*
+
+# Then include only what we need
+!composer.json
+!src/
+!public/index.php
+!public/.htaccess
+!config/
+!routes/
+!resources/views/
+!resources/lang/
+!app.php
+!index.php
+!*.php
+
+# Include docker configuration files
+!docker/php/
+
+# Exclude everything in src except PHP files
+src/**/*
+!src/**/*.php
+
+# Exclude everything in public except essential files
+public/*
+!public/index.php
+!public/.htaccess
+
+# Exclude binary files even if they match the whitelist
+*.jpg
+*.jpeg
+*.png
+*.gif
+*.bmp
+*.tiff
+*.ico
+*.webp
+*.pdf
+*.zip
+*.tar.gz
+*.rar
+*.7z
+*.exe
+*.dll
+*.so
+*.dylib
+*.bin
+*.dat
+# Git und Entwicklungstools
 .git
+.gitignore
+.editorconfig
+
+# Node.js
+node_modules
+npm-debug.log
+package-lock.json
+
+# PHP
 vendor
-storage/logs/*
-storage/app/*
-storage/framework/cache/*
-storage/framework/sessions/*
-storage/framework/views/*
+composer.lock
+.php-cs-fixer.cache
+
+# Umgebungsdateien
+.env*
+!.env.example
+
+# Cache und temporäre Dateien
+storage/logs
+storage/cache
+storage/sessions
 *.log
+*.cache
+*.tmp
+
+# Datenbank
+*.sqlite
+*.db
+
+# Build-Dateien
+*.md
+Makefile
+build.sh
+deploy.sh
+
+# IDE
+.vscode
+.idea
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Spezifische Dateien dieses Projekts
+m
+ms
+qodana.yaml
+phpunit.xml
+# Exclude directories that might contain problematic files
+.git/
+node_modules/
+vendor/
+storage/
+cache/
+tmp/
+temp/
+logs/
+.vscode/
+.idea/
+*.log
+.env*
+.DS_Store
+Thumbs.db
diff --git a/.env.example b/.env.example
index c2c8332f..7170c580 100644
--- a/.env.example
+++ b/.env.example
@@ -1,8 +1,44 @@
 # Projektname für Docker Compose
 COMPOSE_PROJECT_NAME=michaelschiemer
+# Anwendungseinstellungen
+APP_ENV=development
+APP_DEBUG=true
 
+# API-Konfiguration
+RAPIDMAIL_USERNAME=3f60a5c15c3d49c631d0e75b7c1090a3859423a7
+RAPIDMAIL_PASSWORD=572d25dc36e620f14c89e9c75c02c1f3794ba3c0
+RAPIDMAIL_DEFAULT_LIST_ID=776
+
+# Shopify API-Konfiguration
+SHOPIFY_SHOP_DOMAIN=michaelschiemer.myshopify.com
+SHOPIFY_ACCESS_TOKEN=shpat_123456789abcdef
+SHOPIFY_API_VERSION=2024-04
+
+# Datenbank-Konfiguration (falls benötigt)
+# DB_HOST=localhost
+# DB_PORT=3306
+# DB_DATABASE=meine_datenbank
+# DB_USERNAME=root
+# DB_PASSWORD=secret
+
+# Redis-Konfiguration (falls benötigt)
+# REDIS_HOST=redis
+# REDIS_PORT=6379
+# REDIS_PASSWORD=null
 # Externer Port für Web-Zugriff
 APP_PORT=8000
 
 # PHP-Version (für Build)
 PHP_VERSION=8.4
+# Redis Konfiguration
+REDIS_SCHEME=tcp
+REDIS_HOST=redis
+REDIS_PORT=6379
+
+# Rate Limiting Konfiguration
+RATE_LIMIT_DEFAULT=60
+RATE_LIMIT_WINDOW=60
+RATE_LIMIT_AUTH=10
+RATE_LIMIT_AUTH_WINDOW=300
+RATE_LIMIT_API=30
+RATE_LIMIT_API_WINDOW=60
\ No newline at end of file
diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md
new file mode 100644
index 00000000..1649b789
--- /dev/null
+++ b/.github/pull_request_template.md
@@ -0,0 +1,43 @@
+# Pull Request
+
+## Beschreibung
+
+Bitte beschreiben Sie kurz die Änderungen, die in diesem Pull Request enthalten sind.
+
+## Art der Änderung
+
+Bitte markieren Sie die zutreffenden Optionen:
+
+- [ ] Bugfix (nicht-kritische Änderung, die ein Problem behebt)
+- [ ] Neue Funktion (nicht-kritische Änderung, die Funktionalität hinzufügt)
+- [ ] Breaking Change (Änderung, die zu Inkompatibilitäten führt)
+- [ ] Dokumentationsänderung
+- [ ] Performance-Verbesserung
+
+## Wie wurde getestet?
+
+Bitte beschreiben Sie, wie Sie Ihre Änderungen getestet haben.
+
+## Dokumentation
+
+**Sind Dokumentationsänderungen notwendig?**
+
+- [ ] Ja (wenn ja, bitte unten Details angeben)
+- [ ] Nein
+
+**Welche Dokumentation wurde aktualisiert?**
+
+- [ ] Code-Kommentare
+- [ ] README/Markdown-Dateien
+- [ ] PHPDoc
+- [ ] Andere: _bitte angeben_
+
+## Checkliste:
+
+- [ ] Mein Code folgt den Coding-Guidelines des Projekts
+- [ ] Ich habe Tests für meinen Code geschrieben
+- [ ] Alle Tests bestehen
+- [ ] Ich habe die Dokumentation aktualisiert (wenn nötig)
+- [ ] Ich habe die Änderungen mit dem KI-Assistenten überprüft
+- [ ] Ich habe die Leistung bei großen Datenmengen getestet (wenn relevant)
+- [ ] Ich habe sichergestellt, dass keine externen Abhängigkeiten hinzugefügt wurden
diff --git a/.gitignore b/.gitignore
index 5d488901..a50d2a1f 100644
--- a/.gitignore
+++ b/.gitignore
@@ -10,7 +10,7 @@ vendor/
 .env
 *.log
 *.retry
-ansible/.vault_pass
+x_ansible/.vault_pass
 *.Zone.Identifier
 
 # Backup Dateien
@@ -20,4 +20,13 @@ ansible/.vault_pass
 .php-cs-fixer.php
 
 
-#ssl/*.pem
+ssl/*.pem
+
+node_modules
+storage/uploads/*
+storage/logs/.gitkeep
+dist/
+
+.archive/
+
+!/storage/uploads/videos/
diff --git a/.junie/guidelines.md b/.junie/guidelines.md
new file mode 100644
index 00000000..e8e0891c
--- /dev/null
+++ b/.junie/guidelines.md
@@ -0,0 +1,12 @@
+# Project Guidelines
+    
+This is a placeholder of the project guidelines for Junie.
+Replace this text with any project-level instructions for Junie, e.g.:
+
+* What is the project structure
+* Whether Junie should run tests to check the correctness of the proposed solution
+* How does Junie run tests (once it requires any non-standard approach)
+* Whether Junie should build the project before submitting the result
+* Any code-style related instructions
+
+As an option you can ask Junie to create these guidelines for you.
diff --git a/Makefile b/Makefile
index 0abac6cc..b414722a 100644
--- a/Makefile
+++ b/Makefile
@@ -9,10 +9,10 @@ ENV ?= dev
 # Standart Docker Compose Befehle
 
 up: ## Startet alle Docker-Container
-	./bin/up
+	docker compose up -d
 
 down: ## Stoppt alle Container
-	./bin/down
+	docker compose down
 
 build:
 	docker compose build
@@ -51,6 +51,10 @@ clean: ## Entfernt temporäre Dateien
 	find . -type f -name "*Zone.Identifier" -delete
 	find . -type f -name "*.retry" -delete
 
+
+static: ## Generate Static Files
+	./bin/generate-static.php
+
 # Projektstatus
 status: ## Zeigt Container-Status
 	@echo "Aktuelles Projekt: $(PROJECT_NAME)"
@@ -70,6 +74,11 @@ help: ## Zeigt diese Hilfe an
 	@echo ""
 
 
+console:
+	docker exec -it php php console.php $(Args)
+
+
+
 composer: ## Use Composer
 	docker compose exec php composer $(ARGS)
 
@@ -85,23 +94,46 @@ cs-fix-file: ## Fix code style for a specific file
 cs-fix: ## Fix code style for all PHP files
 	docker compose exec -e PHP_CS_FIXER_IGNORE_ENV=1 php ./vendor/bin/php-cs-fixer fix
 
+setup-ssh: ## SSH-Schlüssel korrekt einrichten
+	mkdir -p ~/.ssh
+	cp /mnt/c/Users/Mike/.ssh/test.michaelschiemer.de ~/.ssh/staging
+	chmod 600 ~/.ssh/staging
+	@echo "SSH-Schlüssel für Staging korrekt eingerichtet"
+
+fix-ssh-perms: ## Korrigiert SSH-Schlüsselberechtigungen (veraltet)
+	chmod 600 /mnt/c/Users/Mike/.ssh/test.michaelschiemer.de
+	@echo "SSH-Schlüsselberechtigungen korrigiert"
+
 health:
 	ansible-playbook ansible/check.yml
 
 
-# Konfiguration
+# Ansible Konfiguration
 ANSIBLE_INVENTORY=ansible/inventory/hosts.ini
 PLAYBOOK_DIR=ansible/playbooks/deploy
+TAGS=
 
-.PHONY: dev staging production
+.PHONY: dev staging production setup-server check
 
-dev:
-	ansible-playbook -i $(ANSIBLE_INVENTORY) $(PLAYBOOK_DIR)/dev.yml #--ask-become-pass
+# Deployment-Ziele
+dev: ## Lokales Deployment (Development)
+	ansible-playbook -i $(ANSIBLE_INVENTORY) $(PLAYBOOK_DIR)/dev.yml --ask-become-pass $(if $(TAGS),--tags="$(TAGS)",)
 
-staging:
-	ansible-playbook -i $(ANSIBLE_INVENTORY) $(PLAYBOOK_DIR)/staging.yml
+staging: ## Staging-Deployment
+	ansible-playbook -i $(ANSIBLE_INVENTORY) $(PLAYBOOK_DIR)/staging.yml $(if $(TAGS),--tags="$(TAGS)",)
 
-production:
-	ansible-playbook -i $(ANSIBLE_INVENTORY) $(PLAYBOOK_DIR)/production.yml
+production: ## Produktions-Deployment
+	ansible-playbook -i $(ANSIBLE_INVENTORY) $(PLAYBOOK_DIR)/production.yml $(if $(TAGS),--tags="$(TAGS)",)
 
-.PHONY: up down build restart logs ps phpinfo deploy setup clean status
+setup-server: ## Server-Grundkonfiguration
+	ansible-playbook -i $(ANSIBLE_INVENTORY) ansible/setup.yml $(if $(LIMIT),--limit="$(LIMIT)",) $(if $(TAGS),--tags="$(TAGS)",)
+
+check: ## Serververbindung prüfen
+	ansible -i $(ANSIBLE_INVENTORY) all -m ping $(if $(LIMIT),--limit="$(LIMIT)",)
+
+
+# Beispielaufrufe:
+# make staging TAGS="deploy,check"
+# make setup-server LIMIT="staging" TAGS="docker"
+
+.PHONY: up down build restart logs ps phpinfo deploy setup clean status fix-ssh-perms setup-ssh
diff --git a/README-image-upload.md b/README-image-upload.md
new file mode 100644
index 00000000..2b35322e
--- /dev/null
+++ b/README-image-upload.md
@@ -0,0 +1,128 @@
+# Bild-Upload-System
+
+Dieses Dokument beschreibt das Bild-Upload-System des Frameworks.
+
+## Funktionen
+
+- Strukturierte Ordnerhierarchie basierend auf Datum und ID
+- Automatische Erstellung mehrerer Bildvarianten (Größen)
+- Unterstützung für mehrere Dateiformate (JPG, WebP, AVIF)
+- Duplikat-Erkennung über SHA256-Hash
+- Sicherheitsvalidierung von Dateitypen und -größen
+- Performance-Optimierung durch moderne Bildformate
+
+## Ordnerstruktur
+
+Die Bilder werden in folgendem Muster gespeichert:
+
+```
+/uploads
+└─ /YYYY (Jahr)
+   └─ /MM (Monat)
+      └─ /DD (Tag)
+         └─ /XXX (ID Teil 1)
+            └─ /XXX (ID Teil 2)
+               └─ /XXX (ID Teil 3)
+                  └─ original.jpg
+                  └─ thumbnail.jpg
+                  └─ thumbnail.webp
+                  └─ thumbnail.avif
+                  └─ small.jpg
+                  └─ small.webp
+                  └─ small.avif
+                  └─ medium.jpg
+                  └─ medium.webp
+                  └─ medium.avif
+                  └─ large.jpg
+                  └─ large.webp
+                  └─ large.avif
+```
+
+## Bildvarianten
+
+Folgende Bildvarianten werden automatisch erstellt:
+
+- **thumbnail**: 150x150px, quadratisch zugeschnitten
+- **small**: 400x400px, proportional skaliert
+- **medium**: 800x800px, proportional skaliert
+- **large**: 1200x1200px, proportional skaliert
+
+## Dateiformate
+
+Jede Variante wird in folgenden Formaten gespeichert:
+
+- **JPG**: Für universelle Kompatibilität
+- **WebP**: Für moderne Browser mit besserer Kompression
+- **AVIF**: Für neueste Browser mit bester Kompression (falls PHP-Unterstützung vorhanden)
+
+## Datenbank-Schema
+
+Das System verwendet zwei Tabellen:
+
+### `images`
+
+- `id`: Primärschlüssel
+- `filename`: Generierter Dateiname
+- `original_filename`: Originaler Upload-Dateiname
+- `mime_type`: MIME-Typ des Bildes
+- `file_size`: Dateigröße in Bytes
+- `width`: Bildbreite in Pixeln
+- `height`: Bildhöhe in Pixeln
+- `hash`: SHA256-Hash für Duplikat-Erkennung
+- `upload_path`: Relativer Pfad zum Bild
+- `created_at`: Erstellungszeitpunkt
+- `updated_at`: Letzter Aktualisierungszeitpunkt
+
+### `image_variants`
+
+- `id`: Primärschlüssel
+- `image_id`: Fremdschlüssel zur `images`-Tabelle
+- `variant`: Name der Variante (thumbnail, small, medium, large)
+- `format`: Dateiformat (jpg, webp, avif)
+- `width`: Bildbreite in Pixeln
+- `height`: Bildhöhe in Pixeln
+- `file_size`: Dateigröße in Bytes
+- `filename`: Name der Variantendatei
+- `created_at`: Erstellungszeitpunkt
+
+## Verwendung
+
+### Bild hochladen
+
+```php
+// In einem Controller
+public function upload(Request $request)
+{
+    $file = $request->files->get('image');
+    $image = $this->imageService->uploadImage($file);
+
+    // URL zu einer Bildvariante erhalten
+    $thumbnailUrl = $this->imageService->getImageUrl($image, 'thumbnail', 'webp');
+    $mediumUrl = $this->imageService->getImageUrl($image, 'medium', 'jpg');
+}
+```
+
+### Bild anzeigen
+
+```html
+<!-- Optimale Bildauswahl mit picture-Element -->
+<picture>
+    <source srcset="/media/uploads/2025/06/26/001/234/567/1234567/medium.avif" type="image/avif">
+    <source srcset="/media/uploads/2025/06/26/001/234/567/1234567/medium.webp" type="image/webp">
+    <img src="/media/uploads/2025/06/26/001/234/567/1234567/medium.jpg" alt="Beschreibung">
+</picture>
+```
+
+## Technische Details
+
+### Bildverarbeitung
+
+Die Bildverarbeitung erfolgt mit der GD-Bibliothek. Für die Verwendung von AVIF ist PHP 8.1+ mit AVIF-Unterstützung erforderlich.
+
+### Performance
+
+Bilder werden mit Cache-Headers ausgeliefert, die eine lange Browser-Cache-Dauer ermöglichen, um Bandbreite zu sparen und die Ladezeit zu verbessern.
+
+### Sicherheit
+
+Alle Uploads werden validiert, um sicherzustellen, dass nur erlaubte Bildtypen verarbeitet werden. Es werden sichere, eindeutige Dateinamen generiert, um Konflikte zu vermeiden.
diff --git a/README-static-site.md b/README-static-site.md
new file mode 100644
index 00000000..e0326a32
--- /dev/null
+++ b/README-static-site.md
@@ -0,0 +1,118 @@
+# Static Site Generator
+
+Diese Komponente ermöglicht die Generierung statischer HTML-Seiten aus den dynamischen Routen der Anwendung, die mit dem `#[StaticPage]` Attribut markiert sind.
+
+## Funktionsweise
+
+Der Static Site Generator identifiziert alle Controller-Methoden, die mit dem `#[StaticPage]` Attribut markiert sind, und erzeugt für jede entsprechende Route eine statische HTML-Datei im `public/static` Verzeichnis. Die Verzeichnisstruktur wird entsprechend der URL-Struktur erstellt.
+
+## Markieren von Routen als statische Seiten
+
+Um eine Route als statische Seite zu kennzeichnen, füge das `#[StaticPage]` Attribut zur Controller-Methode hinzu:
+
+```php
+use App\Framework\Attributes\StaticPage;
+use App\Framework\Attributes\Route;
+
+class HomeController
+{
+    #[Route('/')]
+    #[StaticPage]
+    public function index()
+    {
+        // Diese Seite wird als statische Seite generiert
+        return new ViewResult(new HomeViewModel());
+    }
+
+    #[Route('/about')]
+    #[StaticPage(outputPath: 'ueber-uns')]
+    public function about()
+    {
+        // Diese Seite wird mit benutzerdefiniertem Pfad generiert
+        return new ViewResult(new AboutViewModel());
+    }
+
+    #[Route('/dynamic-content')]
+    public function dynamic()
+    {
+        // Diese Seite wird NICHT als statische Seite generiert
+        return new ViewResult(new DynamicViewModel());
+    }
+}
+```
+
+## Verwendung
+
+### Über die Kommandozeile
+
+```bash
+# Nur mit #[StaticPage] markierte Routen generieren (Standard)
+php bin/generate-static.php
+
+# Oder mit Composer
+composer generate-static
+
+# Alle GET-Routen generieren (ignoriert #[StaticPage] Attribut)
+php bin/generate-static.php --all
+
+# Mit benutzerdefinierten Optionen
+php bin/generate-static.php --manual-routes=config/static-routes.json --output=public/static --exclude="\/api\/.*,\/admin\/.*"
+```
+
+### Verfügbare Optionen
+
+- `--manual-routes=<datei>`: Pfad zu einer JSON-Datei mit zu generierenden Routen (überschreibt Attributerkennung)
+- `--output=<ordner>`: Ausgabeverzeichnis (Standard: public/static)
+- `--exclude=<muster>`: Kommagetrennte Liste von Regex-Mustern für auszuschließende Routen
+- `--all`: Alle GET-Routen generieren (ignoriert #[StaticPage] Attribut)
+- `--help`: Hilfe anzeigen
+
+### Programmatisch verwenden
+
+```php
+use App\Framework\StaticSite\StaticSiteGenerator;
+use App\Framework\StaticSite\StaticPageCollector;
+
+// Anwendung initialisieren
+$app = /* ... */;
+
+// Routen mit StaticPage-Attribut sammeln
+$router = $app->getContainer()->get(HttpRouter::class);
+$staticPageCollector = new StaticPageCollector($router);
+$routes = $staticPageCollector->collectStaticPages();
+
+// Oder alle GET-Routen sammeln
+// $routes = $staticPageCollector->collectAllGetRoutes();
+
+// Generator initialisieren
+$generator = new StaticSiteGenerator($app, $routes);
+
+// Optional: Ausgabeverzeichnis anpassen
+$generator->setOutputDirectory(__DIR__ . '/path/to/output');
+
+// Statische Seiten generieren
+$generator->generate();
+```
+
+## Ausgabestruktur
+
+Für jede markierte Route wird eine entsprechende Datei oder Verzeichnisstruktur erstellt:
+
+- `/` → `/public/static/index.html`
+- `/about` → `/public/static/about/index.html` (oder benutzerdefinierter Pfad, wenn im Attribut angegeben)
+- `/blog/post-1` → `/public/static/blog/post-1/index.html`
+
+## Erweitertes StaticPage-Attribut
+
+Das `#[StaticPage]` Attribut unterstützt folgende Parameter:
+
+- `outputPath`: Optionaler benutzerdefinierter Ausgabepfad für die statische Seite
+- `prerender`: Ob die Seite beim Deployment vorgerendert werden soll (Standard: true)
+
+## Vorteile statischer Seiten
+
+- Verbesserte Performance durch Wegfall der dynamischen Verarbeitung
+- Geringere Serverlast
+- Einfacheres Hosting (statische Dateien können überall gehostet werden)
+- Verbesserte Sicherheit durch Reduzierung der Angriffsfläche
+- Bessere SEO durch schnellere Ladezeiten
diff --git a/README.md b/README.md
index 0480423d..a0f88a14 100644
--- a/README.md
+++ b/README.md
@@ -1,5 +1,259 @@
 ## 🚀 Quick Start
+# PHP Framework
 
+Ein modulares und erweiterbares PHP-Framework mit API-Client-Integration und Attribut-basiertem Routing.
+
+## Installation
+
+```bash
+# Repository klonen
+git clone https://github.com/username/framework.git
+cd framework
+
+# Abhängigkeiten installieren
+composer install
+
+# Umgebungsvariablen konfigurieren
+cp .env.example .env
+# Bearbeiten Sie .env mit Ihren Einstellungen
+```
+
+## Anwendung starten
+
+Das Framework kann entweder mit dem eingebauten PHP-Webserver oder mit einem Webserver wie Apache oder Nginx ausgeführt werden.
+
+### Eingebauter PHP-Webserver
+
+```bash
+php -S localhost:8000 -t public/
+```
+
+### Nginx-Konfiguration
+
+```nginx
+server {
+    listen 80;
+    server_name yourdomain.com;
+    root /path/to/framework/public;
+
+    index index.php;
+
+    location / {
+        try_files $uri $uri/ /index.php?$query_string;
+    }
+
+    location ~ \.php$ {
+        fastcgi_pass unix:/var/run/php/php8.1-fpm.sock;
+        fastcgi_index index.php;
+        fastcgi_param SCRIPT_FILENAME $realpath_root$fastcgi_script_name;
+        include fastcgi_params;
+    }
+}
+```
+
+## Architektur
+
+Das Framework folgt einer modularen Architektur mit den folgenden Hauptkomponenten:
+
+### Core
+
+- **Application**: Steuert den Anwendungslebenszyklus
+- **Container**: Dependency Injection Container
+- **Router**: Attribute-basiertes Routing
+- **Middleware**: HTTP-Middleware-Chain
+
+### HTTP
+# DateTime-Modul für das Framework
+
+Dieses Modul bietet eine umfassende Unterstützung für DateTime-Operationen im Framework mit einem Fokus auf Testbarkeit, Immutabilität und Zeitzonen-Unterstützung.
+
+## Hauptkomponenten
+
+### Clock-Interface
+
+Das `Clock`-Interface abstrahiert den Zugriff auf die aktuelle Zeit und stellt sicher, dass Anwendungscode testbar bleibt:
+
+```php
+// Produktionscode verwendet SystemClock
+$clock = new SystemClock();
+$now = $clock->now();
+
+// Testcode kann FrozenClock verwenden
+$clock = new FrozenClock('2021-01-01 00:00:00');
+$frozenTime = $clock->now(); // Gibt immer das gleiche Datum zurück
+```
+
+### FrozenClock für Tests
+
+Die `FrozenClock`-Klasse ist besonders nützlich für Tests, bei denen Sie die Zeit kontrollieren müssen:
+
+```php
+$clock = new FrozenClock('2021-01-01 00:00:00');
+
+// Zeit vorstellen
+$clock->moveForward('PT1H'); // Eine Stunde vorstellen
+
+// Zeit zurückstellen
+$clock->moveBackward('P1D'); // Einen Tag zurückstellen
+
+// Zeit direkt setzen
+$clock->setTo('2022-01-01 00:00:00');
+```
+
+### DateTimeFormatter
+
+Der `DateTimeFormatter` bietet bequeme Methoden zum konsistenten Formatieren von Datums- und Zeitwerten:
+
+```php
+$formatter = new DateTimeFormatter();
+
+// ISO8601-Format (für APIs und JSON)
+$iso = $formatter->formatIso8601($date); // 2021-01-01T12:34:56+00:00
+
+// SQL-Format
+$sql = $formatter->formatSql($date); // 2021-01-01 12:34:56
+
+// Nur Datum
+$dateOnly = $formatter->formatDate($date); // 2021-01-01
+
+// Benutzerdefiniertes Format
+$custom = $formatter->format($date, 'd.m.Y H:i'); // 01.01.2021 12:34
+```
+
+### DateRange
+
+Die `DateRange`-Klasse ermöglicht die einfache Arbeit mit Zeiträumen:
+
+```php
+// Zeitraum erstellen
+$range = DateRange::fromStrings('2021-01-01', '2021-01-31');
+
+// Prüfen, ob ein Datum im Bereich liegt
+$isInRange = $range->contains($someDate);
+
+// Prüfen, ob sich Bereiche überschneiden
+$doOverlap = $range->overlaps($otherRange);
+
+// Dauer berechnen
+$seconds = $range->getDurationInSeconds();
+```
+
+## DI-Container Integration
+
+Das Modul lässt sich nahtlos in den DI-Container des Frameworks integrieren:
+
+```php
+// In Ihrer Bootstrap-Datei oder Service-Provider
+$container->singleton(Clock::class, SystemClock::class);
+$container->singleton(DateTimeFormatter::class, DateTimeFormatter::class);
+
+// Oder den bereitgestellten ServiceProvider verwenden
+$dateTimeServiceProvider = new DateTimeServiceProvider();
+$dateTimeServiceProvider->register($container);
+```
+
+## Testunterstützung
+
+Für Tests kann die FrozenClock einfach registriert werden:
+
+```php
+// In Ihrem Test-Setup
+$frozenClock = new FrozenClock('2021-01-01 00:00:00');
+$container->instance(Clock::class, $frozenClock);
+
+// Zeit während des Tests manipulieren
+$frozenClock->moveForward('PT1H');
+```
+- **Request/Response**: HTTP-Nachrichten
+- **HttpClient**: HTTP-Client für API-Anfragen
+
+### API
+
+- **ApiRequestTrait**: Hilfsklasse für API-Clients
+- **Integrierte Clients**: RapidMail, Shopify
+
+## Features
+
+- **Attribut-basiertes Routing**: Deklaratives Routing mit PHP 8 Attributen
+- **Dependency Injection**: Automatische Auflösung von Abhängigkeiten
+- **Middleware-System**: Erweiterbare HTTP-Middleware-Chain
+- **API-Clients**: Integrierte Clients für gängige APIs
+- **Konfigurationsmanagement**: Flexible Konfiguration mit Umgebungsvariablen
+
+## Beispiele
+
+### Controller mit Routing
+
+```php
+<?php
+
+namespace App\Application\Example;
+
+use App\Framework\Attributes\Route;
+use App\Framework\Router\Result\JsonResult;
+
+final class ExampleController
+{
+    #[Route(path: '/api/example', method: 'GET')]
+    public function getExample(): JsonResult
+    {
+        return new JsonResult([
+            'success' => true,
+            'message' => 'Hello World!'
+        ]);
+    }
+}
+```
+
+### API-Client verwenden
+
+```php
+<?php
+
+namespace App\Application\Newsletter;
+
+use App\Framework\Attributes\Route;use App\Framework\Http\Status;use App\Framework\Router\Result\JsonResult;use App\Infrastructure\Api\RapidMailClient;use Archive\Config\ApiConfig;
+
+final class NewsletterController
+{
+    private RapidMailClient $client;
+
+    public function __construct()
+    {
+        $this->client = new RapidMailClient(
+            ApiConfig::RAPIDMAIL_USERNAME->value,
+            ApiConfig::RAPIDMAIL_PASSWORD->value
+        );
+    }
+
+    #[Route(path: '/newsletter/register', method: 'POST')]
+    public function register(NewsletterRequest $request): JsonResult
+    {
+        $result = $this->client->addRecipient(
+            $request->name,
+            $request->email,
+            ApiConfig::getRapidmailListId()
+        );
+
+        return new JsonResult(
+            ['success' => true, 'data' => $result],
+            Status::CREATED
+        );
+    }
+}
+```
+
+## Erweiterung
+
+Das Framework kann durch eigene Komponenten und Module erweitert werden:
+
+- **Eigene Middleware**: Erstellen Sie benutzerdefinierte Middleware-Klassen
+- **Attribute**: Definieren Sie eigene Attribute und Mapper
+- **API-Clients**: Integrieren Sie zusätzliche APIs mit dem ApiRequestTrait
+
+## Lizenz
+
+MIT
 ```bash
 # Starten
 make up
diff --git a/ansible/group_vars/all.yml b/ansible/group_vars/all.yml
deleted file mode 100644
index 7a473892..00000000
--- a/ansible/group_vars/all.yml
+++ /dev/null
@@ -1,39 +0,0 @@
-# Basis-Konfiguration
-app_name: michaelschiemer
-app_domain: test.michaelschiemer.de
-app_email: kontakt@michaelschiemer.de
-
-# Verzeichnisse
-project_root: "{{ playbook_dir | dirname }}"
-app_root: /var/www/{{ app_name }}
-app_public: "{{ app_root }}/public"
-
-# Docker
-docker_version: "20.10"
-docker_compose_version: "2.24.5"
-
-# Benutzer
-deploy_user: deploy
-
-# Let's Encrypt
-letsencrypt_enabled: true
-letsencrypt_certbot_method: webroot  # oder standalone oder nginx
-
-
-#netcup_customer_id: "218722"
-#netcup_api_key: "dmJINUMyNjRmOG1aNDViajZHN2JkOTFRUjU3ckE5ZjJ1Zm1vUz"
-#netcup_api_password: "iGWL8Hl4m93DgESsP/MPXmtDd0hEVkZ3480Na0psTlXRALnopl"
-#netcup_vserver_id: "v2202309206672239295"
-
-
-# fallback_ip:
-
-wg_all_clients_private_keys:
-  michael: "PITbFZ3UfY5vD5dYUCELO37Qo2W8I4R8+r6D9CeMrm4="
-
-
-
-wireguard_clients:
-  - name: michael
-    address: 10.8.0.2
-    public_key: DEIN_PUBLIC_KEY
diff --git a/ansible/inventory.ini b/ansible/inventory.ini
deleted file mode 100644
index d6bc2e36..00000000
--- a/ansible/inventory.ini
+++ /dev/null
@@ -1,8 +0,0 @@
-#[web]
-#localhost ansible_connection=local
-
-[web]
-94.16.110.151 ansible_user=deploy ansible_ssh_private_key_file=/mnt/c/Users/Mike/.ssh/test.michaelschiemer.de
-
-[vpn]
-94.16.110.151 ansible_user=deploy
diff --git a/ansible/inventory/hosts.ini b/ansible/inventory/hosts.ini
deleted file mode 100644
index e766ecf8..00000000
--- a/ansible/inventory/hosts.ini
+++ /dev/null
@@ -1,12 +0,0 @@
-[localhost]
-127.0.0.1 ansible_connection=local
-
-[staging]
-94.16.110.151 ansible_user=deploy ansible_ssh_private_key_file=/mnt/c/Users/Mike/.ssh/test.michaelschiemer.de
-
-[production]
-
-
-[vpn]
-94.16.110.151 ansible_user=deploy
-
diff --git a/ansible/playbooks/deploy.yml b/ansible/playbooks/deploy.yml
deleted file mode 100644
index 359dbcb8..00000000
--- a/ansible/playbooks/deploy.yml
+++ /dev/null
@@ -1,24 +0,0 @@
-- name: Deployment in jeweilige Umgebung
-  hosts: all
-  become: true
-  gather_facts: false
-
-  vars:
-    docker_compose_project_path: "/var/www/michaelschiemer/"
-    env_file_path: "/var/www/michaelschiemer/.env"
-
-    deploy_root: /var/www/michaelschiemer
-    deploy_public: "{{ deploy_root }}/public"
-    deploy_user: deploy
-
-
-    app_domain: "example.com"           # Passe ggf. an
-    project_root: "{{ playbook_dir }}/../.."
-
-
-  roles:
-    - app
-    - nginx
-    - php
-    - redis
-
diff --git a/ansible/playbooks/deploy/dev.yml b/ansible/playbooks/deploy/dev.yml
deleted file mode 100644
index d1beaee6..00000000
--- a/ansible/playbooks/deploy/dev.yml
+++ /dev/null
@@ -1,26 +0,0 @@
-- name: Deployment für DEV (localhost)
-  hosts: localhost
-  become: true
-  gather_facts: false
-
-  vars:
-    docker_compose_project_path: "/home/michael/dev/michaelschiemer"
-    env_file_path: "/var/www/michaelschiemer/.env"
-
-    deploy_root: /var/www/michaelschiemer
-    deploy_public: "{{ deploy_root }}/public"
-    deploy_user: deploy
-
-    app_domain: "localhost"           # Passe ggf. an
-    project_root: "/home/michael/dev/michaelschiemer"
-
-
-  roles:
-    #- app
-    - nginx
-    - php
-    - redis
-
-  tasks:
-    - name: Common Deployment Tasks
-      import_tasks: ../deploy/includes/deploy_common.yml
diff --git a/ansible/playbooks/deploy/includes/deploy_common.yml b/ansible/playbooks/deploy/includes/deploy_common.yml
deleted file mode 100644
index 1aad0745..00000000
--- a/ansible/playbooks/deploy/includes/deploy_common.yml
+++ /dev/null
@@ -1,29 +0,0 @@
-- name: Docker Compose Files & Konfigurationen synchronisieren
-  ansible.builtin.copy:
-    src: "{{ item.src }}"
-    dest: "{{ docker_compose_project_path }}/{{ item.dest }}"
-    owner: root
-    group: root
-    mode: 0644
-  loop:
-    - { src: '{{ project_root }}/docker-compose.yml', dest: 'docker-compose.yml' }
-    - { src: '{{ project_root }}/.env', dest: '.env' }
-    # Weitere Konfigdateien nach Bedarf (z.B. nginx.conf, redis.conf, ...)
-    - { src: '{{ project_root }}/docker/nginx/nginx.conf', dest: 'nginx.conf' }
-
-- name: "Docker Compose: Container hochfahren (Build & Start)"
-  ansible.builtin.command: |
-    docker-compose -f {{ docker_compose_project_path }}/docker-compose.yml up -d --build
-  args:
-    chdir: "{{ docker_compose_project_path }}"
-
-- name: Status prüfen
-  ansible.builtin.command: |
-    docker-compose -f {{ docker_compose_project_path }}/docker-compose.yml ps
-  args:
-    chdir: "{{ docker_compose_project_path }}"
-  register: compose_ps
-
-- name: Ergebnis anzeigen
-  ansible.builtin.debug:
-    var: compose_ps.stdout_lines
diff --git a/ansible/playbooks/deploy/production.yml b/ansible/playbooks/deploy/production.yml
deleted file mode 100644
index 039ef595..00000000
--- a/ansible/playbooks/deploy/production.yml
+++ /dev/null
@@ -1,23 +0,0 @@
-- name: Deployment für PRODUCTION
-  hosts: production
-  become: true
-  gather_facts: false
-
-  vars:
-    docker_compose_project_path: "/var/www/www.michaelschiemer.de/"
-    env_file_path: "/var/www/www.michaelschiemer.de/.env"
-    deploy_root: /var/www/www.michaelschiemer.de
-    deploy_public: "{{ deploy_root }}/public"
-    deploy_user: deploy
-    app_domain: "michaelschiemer.de"
-    project_root: "{{ playbook_dir }}/../.."
-
-  roles:
-    - app
-    - nginx
-    - php
-    - redis
-
-  tasks:
-    - name: Common Deployment Tasks
-      import_tasks: ../deploy/includes/deploy_common.yml
diff --git a/ansible/playbooks/deploy/staging.yml b/ansible/playbooks/deploy/staging.yml
deleted file mode 100644
index e9b74f17..00000000
--- a/ansible/playbooks/deploy/staging.yml
+++ /dev/null
@@ -1,23 +0,0 @@
-- name: Deployment für STAGING
-  hosts: staging
-  become: true
-  gather_facts: false
-
-  vars:
-    docker_compose_project_path: "/var/www/stage.michaelschiemer/"
-    env_file_path: "/var/www/stage.michaelschiemer/.env"
-    deploy_root: /var/www/stage.michaelschiemer
-    deploy_public: "{{ deploy_root }}/public"
-    deploy_user: deploy
-    app_domain: "stage.example.com"
-    project_root: "{{ playbook_dir }}/../.."
-
-  roles:
-    - app
-    - nginx
-    - php
-    - redis
-
-  tasks:
-    - name: Common Deployment Tasks
-      import_tasks: ../deploy/includes/deploy_common.yml
diff --git a/ansible/playbooks/setup.yml b/ansible/playbooks/setup.yml
deleted file mode 100644
index 19aad3c3..00000000
--- a/ansible/playbooks/setup.yml
+++ /dev/null
@@ -1,11 +0,0 @@
----
-- name: Basis Setup für alle Zielsysteme
-  hosts: all
-  become: true
-  #gather_facts: true
-
-  roles:
-    #- common
-    - docker
-    #- webserver
-    #- app
diff --git a/ansible/roles/app/tasks/main.yml b/ansible/roles/app/tasks/main.yml
deleted file mode 100644
index ebc2d544..00000000
--- a/ansible/roles/app/tasks/main.yml
+++ /dev/null
@@ -1,134 +0,0 @@
-- name: Zielverzeichnis erstellen
-  file:
-    path: "{{ deploy_root }}"
-    state: directory
-    owner: "{{ deploy_user }}"
-    group: "{{ deploy_user }}"
-    mode: '0755'
-
-- name: SSL-Verzeichnis sicherstellen
-  file:
-    path: "{{ deploy_root }}/ssl"
-    state: directory
-    owner: "{{ deploy_user }}"
-    group: "{{ deploy_user }}"
-    mode: '0755'
-
-- name: SSL-Zertifikate prüfen
-  stat:
-    path: "/etc/letsencrypt/live/{{ app_domain }}/fullchain.pem"
-  register: ssl_certs
-
-- name: SSL-Zertifikate kopieren (falls vorhanden)
-  copy:
-    src: "{{ item.src }}"
-    dest: "{{ item.dest }}"
-    remote_src: yes
-    owner: "{{ deploy_user }}"
-    group: "{{ deploy_user }}"
-    mode: '0644'
-  loop:
-    - { src: "/etc/letsencrypt/live/{{ app_domain }}/fullchain.pem", dest: "{{ deploy_root }}/ssl/fullchain.pem" }
-    - { src: "/etc/letsencrypt/live/{{ app_domain }}/privkey.pem", dest: "{{ deploy_root }}/ssl/privkey.pem" }
-  when: ssl_certs.stat.exists
-
-- name: public-Verzeichnis synchronisieren
-  synchronize:
-    src: "{{ playbook_dir }}/../../public/"
-    dest: "{{ deploy_public }}/"
-    delete: yes
-    recursive: yes
-
-- name: Projekt-Stammdaten kopieren
-  copy:
-    src: "{{ playbook_dir }}/../../docker-compose.yml"
-    dest: "{{ deploy_root }}/docker-compose.yml"
-    owner: "{{ deploy_user }}"
-    group: "{{ deploy_user }}"
-    mode: '0644'
-
-- name: .env-Datei prüfen
-  stat:
-    path: "{{ project_root }}/.env"
-  register: env_file
-
-- name: .env kopieren (falls vorhanden)
-  copy:
-    src: "{{ project_root }}/.env"
-    dest: "{{ deploy_root }}/.env"
-    mode: '0644'
-  when: env_file.stat.exists
-
-- name: Quellcode synchronisieren
-  synchronize:
-    src: "{{ playbook_dir }}/../../src/"
-    dest: "{{ deploy_root }}/src/"
-    delete: yes
-    recursive: yes
-
-- name: Docker-Verzeichnis prüfen
-  stat:
-    path: "{{ project_root }}/docker"
-  register: docker_dir
-  delegate_to: localhost
-  become: false
-
-- name: Docker-Configs synchronisieren (falls vorhanden)
-  synchronize:
-    src: "{{ project_root }}/docker/"
-    dest: "{{ deploy_root }}/docker/"
-    delete: yes
-    recursive: yes
-  when: docker_dir.stat.exists
-
-- name: Rechte im Zielverzeichnis korrigieren
-  file:
-    path: "{{ deploy_root }}"
-    state: directory
-    owner: "{{ deploy_user }}"
-    group: "{{ deploy_user }}"
-    mode: '0755'
-    recurse: yes
-
-# Cache-Verzeichnis für UID/GID 1000 (z.B. appuser im Container)
-- name: Stelle Schreibrechte für Cache-Verzeichnis her
-  file:
-    path: "{{ deploy_root }}/cache"
-    state: directory
-    owner: 1000
-    group: 1000
-    mode: '0775'
-    recurse: yes
-
-- name: Docker Compose neu bauen und starten
-  shell: |
-    docker compose down
-    docker compose up -d --build
-  args:
-    chdir: "{{ deploy_root }}"
-
-- name: PHP-Container für Composer starten
-  shell: docker compose up -d php
-  args:
-    chdir: "{{ deploy_root }}"
-
-- name: Kurze Wartezeit bis PHP-Container bereit
-  wait_for:
-    timeout: 5
-
-- name: Composer Abhängigkeiten installieren
-  shell: docker compose exec -T php composer install --no-interaction
-  args:
-    chdir: "{{ deploy_root }}"
-  register: composer_result
-  ignore_errors: yes
-
-- name: Composer-Ergebnis anzeigen
-  debug:
-    var: composer_result.stdout_lines
-  when: composer_result.stdout is defined
-
-- name: Composer-Fehler anzeigen
-  debug:
-    var: composer_result.stderr_lines
-  when: composer_result.stderr is defined
diff --git a/ansible/roles/common/tasks/main.yml b/ansible/roles/common/tasks/main.yml
deleted file mode 100644
index 09b5c525..00000000
--- a/ansible/roles/common/tasks/main.yml
+++ /dev/null
@@ -1,26 +0,0 @@
-# Grundlegende Systemkonfiguration
-- name: Basis-Pakete aktualisieren und installieren
-  apt:
-    name:
-      - sudo
-      - vim
-      - htop
-      - git
-      - zip
-      - unzip
-      - curl
-      - wget
-    state: present
-    update_cache: yes
-  become: true
-
-# Passwordless sudo für den deploy-Benutzer einrichten
-- name: Konfiguriere passwordless sudo für deploy-Benutzer
-  lineinfile:
-    path: "/etc/sudoers.d/{{ deploy_user }}"
-    line: "{{ deploy_user }} ALL=(ALL) NOPASSWD: ALL"
-    state: present
-    create: yes
-    mode: '0440'
-    validate: 'visudo -cf %s'
-  become: true
diff --git a/ansible/roles/docker/defaults/main.yml b/ansible/roles/docker/defaults/main.yml
deleted file mode 100644
index 9da18b8d..00000000
--- a/ansible/roles/docker/defaults/main.yml
+++ /dev/null
@@ -1,3 +0,0 @@
-docker_compose_version: "v2.29.2"
-docker_install_compose: true
-docker_user: "{{ ansible_user || default('michael' }}"
diff --git a/ansible/roles/docker/tasks/main.yml b/ansible/roles/docker/tasks/main.yml
deleted file mode 100644
index 7f719412..00000000
--- a/ansible/roles/docker/tasks/main.yml
+++ /dev/null
@@ -1,58 +0,0 @@
-- name: Docker-Abhängigkeiten installieren
-  apt:
-    name:
-      - apt-transport-https
-      - ca-certificates
-      - curl
-      - gnupg
-      - lsb-release
-    state: present
-    update_cache: yes
-
-- name: Docker GPG-Schlüssel hinzufügen
-  apt_key:
-    url: https://download.docker.com/linux/{{ ansible_distribution | lower }}/gpg
-    state: present
-
-- name: Docker Repository hinzufügen
-  apt_repository:
-    repo: "deb [arch=amd64] https://download.docker.com/linux/{{ ansible_distribution | lower }} {{ ansible_distribution_release }} stable"
-    state: present
-
-- name: Docker Engine installieren
-  apt:
-    name:
-      - docker-ce
-      - docker-ce-cli
-      - containerd.io
-      - docker-compose-plugin
-    state: present
-    update_cache: yes
-
-- name: Docker Compose installieren (V1 als Fallback)
-  get_url:
-    url: "https://github.com/docker/compose/releases/download/v{{ docker_compose_version }}/docker-compose-linux-x86_64"
-    dest: /usr/local/bin/docker-compose
-    mode: '0755'
-
-- name: Benutzer zur Docker-Gruppe hinzufügen
-  user:
-    name: "{{ ansible_user }}"
-    groups: docker
-    append: yes
-
-- name: Docker-Service starten und aktivieren
-  service:
-    name: docker
-    state: started
-    enabled: yes
-  notify: restart docker
-
-
-- name: Starte Docker-Container via Compose
-  community.docker.docker_compose_v2:
-    #project_src: "{{ playbook_dir | dirname }}/../"   # ggf. anpassen auf deinen Compose-Pfad!
-    project_src: "{{ app_root }}"
-    build: always
-    recreate: always
-
diff --git a/ansible/roles/nginx/defaults/main.yml b/ansible/roles/nginx/defaults/main.yml
deleted file mode 100644
index 0537db87..00000000
--- a/ansible/roles/nginx/defaults/main.yml
+++ /dev/null
@@ -1,5 +0,0 @@
-nginx_conf_template: nginx.conf.j2
-nginx_default_site_template: default.conf.j2
-nginx_ssl_src_dir: "{{ app_root }}/ssl"
-nginx_ssl_dest_dir: "/var/www/michaelschiemer/ssl"
-nginx_target_dir: "/var/www/michaelschiemer/docker/nginx"
diff --git a/ansible/roles/nginx/handlers/main.yml b/ansible/roles/nginx/handlers/main.yml
deleted file mode 100644
index f063c43f..00000000
--- a/ansible/roles/nginx/handlers/main.yml
+++ /dev/null
@@ -1,2 +0,0 @@
-- name: reload nginx
-  ansible.builtin.command: docker exec <nginx_container_name> nginx -s reload
diff --git a/ansible/roles/nginx/tasks/main.yml b/ansible/roles/nginx/tasks/main.yml
deleted file mode 100644
index 9d1cbc57..00000000
--- a/ansible/roles/nginx/tasks/main.yml
+++ /dev/null
@@ -1,37 +0,0 @@
-- name: Stelle das nginx-Verzeichnis sicher
-  ansible.builtin.file:
-    path: "{{ nginx_target_dir }}"
-    state: directory
-    recurse: yes
-    mode: '0755'
-
-- name: Kopiere nginx-Konfiguration (nginx.conf)
-  ansible.builtin.template:
-    src: "{{ nginx_conf_template }}"
-    dest: "{{ nginx_target_dir }}/nginx.conf"
-    mode: '0644'
-
-- name: Kopiere default site conf
-  ansible.builtin.template:
-    src: "{{ nginx_default_site_template }}"
-    dest: "{{ nginx_target_dir }}/default.conf"
-    mode: '0644'
-
-- name: Kopiere docker-entrypoint Skript
-  ansible.builtin.copy:
-    src: docker-entrypoint.sh
-    dest: "{{ nginx_target_dir }}/docker-entrypoint.sh"
-    mode: '0755'
-
-- name: Baue und starte Nginx-Container (optional, wenn Compose separat genutzt wird, dann hier nicht nötig)
-  ansible.builtin.command: docker-compose up -d --build web
-  args:
-    chdir: "{{ docker_compose_project_path }}"
-  when: nginx_target_dir is defined
-  register: nginx_compose_result
-  ignore_errors: true
-
-- name: Zeige Compose-Resultat
-  ansible.builtin.debug:
-    var: nginx_compose_result.stdout_lines
-  when: nginx_compose_result is defined
diff --git a/ansible/roles/wireguard/tasks/configure.yml b/ansible/roles/wireguard/tasks/configure.yml
deleted file mode 100644
index dbcaf692..00000000
--- a/ansible/roles/wireguard/tasks/configure.yml
+++ /dev/null
@@ -1,133 +0,0 @@
-# --------------------------------------------------------
-# WireGuard installieren
-# --------------------------------------------------------
-
-- name: Stelle sicher, dass WireGuard installiert ist
-  apt:
-    name: wireguard
-    state: present
-    update_cache: yes
-  become: true
-  when: ansible_connection != "local"
-
-# --------------------------------------------------------
-# Server-Schlüssel erzeugen und speichern
-# --------------------------------------------------------
-
-- name: Prüfe ob privater Server-Schlüssel existiert
-  stat:
-    path: /etc/wireguard/privatekey
-  register: privkey_file
-  become: true
-  when: ansible_connection != "local"
-
-- name: Erstelle Schlüsselpaar für Server (wenn nicht vorhanden)
-  command: wg genkey
-  register: server_private_key
-  when: ansible_connection != "local" and (not privkey_file.stat.exists | default(true))
-
-- name: Speichere privaten Schlüssel
-  copy:
-    content: "{{ server_private_key.stdout }}"
-    dest: /etc/wireguard/privatekey
-    mode: "0600"
-  when: server_private_key.stdout is defined and server_private_key.stdout is defined
-
-- name: Lies privaten Schlüssel ein
-  slurp:
-    src: /etc/wireguard/privatekey
-  become: true
-  when: ansible_connection != "local"
-
-- name: Erzeuge öffentlichen Server-Schlüssel
-  command: "echo '{{ wg_privkey }}' | wg pubkey"
-  register: wg_pubkey
-  when: ansible_connection != "local"
-
-- name: Privaten Server-Schlüssel anzeigen
-  debug:
-    msg: "{{ server_private_key }}"
-  when: ansible_connection != "local"
-
-# --------------------------------------------------------
-# Client-Key-Erzeugung lokal (einmalig pro Client)
-# --------------------------------------------------------
-
-- name: Generiere privaten Schlüssel für Clients (auf dem Server)
-  command: wg genkey
-  args:
-    creates: "/etc/wireguard/client-{{ item.name }}.key"
-  loop: "{{ wireguard_clients }}"
-  loop_control:
-    label: "{{ item.name }}"
-  register: client_private_keys
-  when: ansible_connection != "local"
-
-
-- name: Erzeuge öffentlichen Schlüssel für Clients
-  command: "echo '{{ client_privkey_result.stdout }}' | wg pubkey"
-  register: client_pubkey_result
-  when:
-    - ansible_connection != "local"
-    - client_privkey_result is defined
-    - client_privkey_result.stdout is defined
-
-- name: wireguard_clients mit public_key anreichern
-  set_fact:
-    wireguard_clients: "{{ wireguard_clients_with_pubkey | default([]) + [ item.0 | combine({'public_key': item.1.stdout|trim }) ] }}"
-  loop: "{{ wireguard_clients | zip(client_public_keys.results) | list }}"
-  when: client_public_keys is defined
-
-- name: Aktuelles wireguard_clients-Set überschreiben
-  set_fact:
-    wireguard_clients: "{{ wireguard_clients_with_pubkey }}"
-  when: wireguard_clients_with_pubkey is defined
-
-# --------------------------------------------------------
-# Konfigurationsdatei erzeugen
-# --------------------------------------------------------
-
-#- debug:
-#    var: wireguard_clients
-
-- name: Render wg0.conf
-  template:
-    src: wg0.conf.j2
-    dest: /etc/wireguard/wg0.conf
-  when: wg_privkey is defined and wg_privkey != ""
-
-# --------------------------------------------------------
-# IP Forwarding & WireGuard aktivieren
-# --------------------------------------------------------
-
-- name: Aktiviere IP-Forwarding
-  sysctl:
-    name: net.ipv4.ip_forward
-    value: 1
-    state: present
-    sysctl_set: yes
-    reload: yes
-  become: true
-  when: ansible_connection != "local"
-
-- name: Starte und aktiviere WireGuard
-  systemd:
-    name: wg-quick@wg0
-    enabled: true
-    state: started
-    daemon_reload: yes
-  become: true
-  when: ansible_connection != "local"
-
-- name: Verteilt für jeden Client die Client-Config
-  template:
-    src: client.conf.j2
-    dest: "/etc/wireguard/clients/{{ item.name }}.conf"
-    owner: root
-    group: root
-    mode: 0600
-  loop: "{{ wireguard_clients }}"
-  #delegate_to: localhost
-  run_once: true
-  become: true
-  when: ansible_connection != "local"
diff --git a/ansible/roles/wireguard/tasks/failsafe.yml b/ansible/roles/wireguard/tasks/failsafe.yml
deleted file mode 100644
index 1d6283d8..00000000
--- a/ansible/roles/wireguard/tasks/failsafe.yml
+++ /dev/null
@@ -1,54 +0,0 @@
----
-# roles/wireguard/tasks/failsafe.yml
-# Sicherstellt, dass SSH über VPN funktioniert und ein Fallback vorhanden ist
-
-- name: Stelle sicher, dass wireguard_network gesetzt ist
-  assert:
-    that:
-      - wireguard_network is defined
-    fail_msg: "wireguard_network muss gesetzt sein (z. B. 10.8.0.0/24)"
-
-- name: Automatisch externe IP als fallback_ip setzen (nur wenn nicht gesetzt)
-  shell: curl -s ifconfig.me
-  register: detected_fallback_ip
-  when: fallback_ip is not defined
-  changed_when: false
-
-- name: Setze fallback_ip dynamisch als Ansible-Fact (wenn nicht gesetzt)
-  set_fact:
-    fallback_ip: "{{ detected_fallback_ip.stdout }}"
-  when: fallback_ip is not defined
-
-- name: (Optional) Erlaube temporär Fallback-SSH von aktueller IP
-  ufw:
-    rule: allow
-    port: 22
-    proto: tcp
-    from_ip: "{{ fallback_ip }}"
-
-- name: Erlaube SSH-Zugriff über VPN
-  ufw:
-    rule: allow
-    port: 22
-    proto: tcp
-    from_ip: "{{ wireguard_network }}"
-
-- name: (Warnung) Prüfe ob VPN-Interface aktiv ist
-  shell: ip a show dev wg0
-  register: vpn_interface_check
-  failed_when: false
-
-- name: Hinweis, wenn VPN-Interface nicht aktiv ist
-  debug:
-    msg: "⚠️ VPN-Interface wg0 scheint nicht aktiv zu sein. SSH über VPN wird nicht funktionieren."
-  when: vpn_interface_check.rc != 0
-
-- name: (Optional) SSH von überall blockieren – nur wenn VPN aktiv
-  when:
-    - ssh_lockdown | default(false)
-    - vpn_interface_check.rc == 0
-  ufw:
-    rule: deny
-    port: 22
-    proto: tcp
-    from_ip: 0.0.0.0/0
diff --git a/ansible/roles/wireguard/tasks/firewall.yml b/ansible/roles/wireguard/tasks/firewall.yml
deleted file mode 100644
index 2110bdf3..00000000
--- a/ansible/roles/wireguard/tasks/firewall.yml
+++ /dev/null
@@ -1,83 +0,0 @@
-# Beispiel: Passe jeden Task in dieser Datei so an:
-- name: Aktiviere Firewall-Regeln für WireGuard
-  ufw:
-    rule: allow
-    port: "{{ wireguard_port }}"
-    proto: udp
-  become: true
-  when: ansible_connection != "local"
-- name: Prüfe, ob UFW installiert ist
-  command: which ufw
-  register: ufw_installed
-  ignore_errors: true
-  changed_when: false
-
-- name: Installiere UFW (falls nicht vorhanden)
-  apt:
-    name: ufw
-    state: present
-    update_cache: yes
-  when: ufw_installed.rc != 0
-
-# Setze Standardrichtlinien (erst Konfiguration, dann am Ende aktivieren)
-- name: Setze Policy für eingehenden Traffic auf "deny"
-  ufw:
-    direction: incoming
-    policy: deny
-
-- name: Setze Policy für ausgehenden Traffic auf "allow"
-  ufw:
-    direction: outgoing
-    policy: allow
-
-# WireGuard-Port freigeben (UDP)
-- name: WireGuard-Port erlauben
-  ufw:
-    rule: allow
-    port: "{{ wireguard_port | default(51820) }}"
-    proto: udp
-
-# SSH von bestimmter IP erlauben
-- name: SSH von deiner IP erlauben (empfohlen)
-  ufw:
-    rule: allow
-    port: 22
-    proto: tcp
-    from_ip: "{{ fallback_ip }}"
-  when: fallback_ip is defined and fallback_ip | length > 0
-
-# Temporär für Tests: SSH für alle erlauben (nur bei Bedarf!)
-- name: SSH von überall erlauben (fail-safe, NUR während Setup/Test)
-  ufw:
-    rule: allow
-    port: 22
-    proto: tcp
-  when: (not (fallback_ip is defined and fallback_ip | length > 0)) or (enable_ssh_from_anywhere | default(false))
-
-# Masquerading für WireGuard
-- name: NAT für WireGuard aktivieren
-  iptables:
-    table: nat
-    chain: POSTROUTING
-    out_interface: "{{ wireguard_exit_interface | default('eth0') }}"
-    source: "{{ wireguard_network }}"
-    jump: MASQUERADE
-
-- name: WireGuard Kernel-Modul laden
-  modprobe:
-    name: wireguard
-    state: present
-
-# UFW ganz am Schluss aktivieren
-- name: UFW aktivieren
-  ufw:
-    state: enabled
-
-- name: Aktive UFW-Regeln anzeigen (zum Debuggen)
-  command: ufw status verbose
-  register: ufw_status
-  changed_when: false
-
-- name: Zeige UFW-Regeln im Ansible-Output
-  debug:
-    var: ufw_status.stdout
diff --git a/ansible/roles/wireguard/tasks/generate_client_single.yml b/ansible/roles/wireguard/tasks/generate_client_single.yml
deleted file mode 100644
index e7c9dae6..00000000
--- a/ansible/roles/wireguard/tasks/generate_client_single.yml
+++ /dev/null
@@ -1,60 +0,0 @@
-- name: Key-Verzeichnis für Client anlegen
-  file:
-    path: "{{ role_path }}/client-keys/{{ client.name }}"
-    state: directory
-    mode: "0700"
-  become: true
-
-- name: Existenz des privaten Schlüssels prüfen
-  stat:
-    path: "{{ role_path }}/client-keys/{{ client.name }}/private.key"
-  register: client_private_key_stat
-
-- name: Privaten Schlüssel generieren (nur falls nicht vorhanden)
-  command: wg genkey
-  register: genpriv
-  args:
-    chdir: "{{ role_path }}/client-keys/{{ client.name }}"
-  when: not client_private_key_stat.stat.exists
-
-- name: Privaten Schlüssel speichern (nur falls nicht vorhanden)
-  copy:
-    content: "{{ genpriv.stdout }}"
-    dest: "{{ role_path }}/client-keys/{{ client.name }}/private.key"
-    mode: "0600"
-  when: not client_private_key_stat.stat.exists
-
-- name: Public Key aus privaten Schlüssel generieren (bei Neuerstellung)
-  command: wg pubkey
-  args:
-    stdin: "{{ genpriv.stdout }}"
-    chdir: "{{ role_path }}/client-keys/{{ client.name }}"
-  register: genpub
-  when: not client_private_key_stat.stat.exists
-
-- name: Bestehenden privaten Schlüssel laden (falls vorhanden)
-  slurp:
-    src: "{{ role_path }}/client-keys/{{ client.name }}/private.key"
-  register: loaded_private
-  when: client_private_key_stat.stat.exists
-
-- name: Public Key aus gespeichertem Private Key erzeugen (falls vorhanden)
-  command: wg pubkey
-  args:
-    stdin: "{{ loaded_private.content | b64decode }}"
-    chdir: "{{ role_path }}/client-keys/{{ client.name }}"
-  register: genpub_existing
-  when: client_private_key_stat.stat.exists
-
-- name: Public Key für Client in Datei schreiben
-  copy:
-    content: >
-      {{ (genpub.stdout if not client_private_key_stat.stat.exists else genpub_existing.stdout) }}
-    dest: "{{ role_path }}/client-keys/{{ client.name }}/public.key"
-    mode: "0644"
-
-- name: Variablen für Client setzen (private/public key, Adresse)
-  set_fact:
-    "wg_{{ client.name }}_private_key": "{{ (genpriv.stdout if not client_private_key_stat.stat.exists else loaded_private.content | b64decode) }}"
-    "wg_{{ client.name }}_public_key": "{{ (genpub.stdout if not client_private_key_stat.stat.exists else genpub_existing.stdout) }}"
-    "wg_{{ client.name }}_address": "{{ client.address }}"
diff --git a/ansible/roles/wireguard/tasks/generate_clients.yml b/ansible/roles/wireguard/tasks/generate_clients.yml
deleted file mode 100644
index f615a5de..00000000
--- a/ansible/roles/wireguard/tasks/generate_clients.yml
+++ /dev/null
@@ -1,39 +0,0 @@
-- name: Schleife über alle WireGuard-Clients
-  include_tasks: generate_client_single.yml
-  loop: "{{ wireguard_clients }}"
-  loop_control:
-    loop_var: client
-
-- name: Generiere privaten Schlüssel für jeden Client
-  shell: "wg genkey"
-  register: wg_client_private_keys
-  loop: "{{ wireguard_clients }}"
-  loop_control:
-    label: "{{ item.name }}"
-  # kein delegate_to mehr!
-  run_once: true  # ggf. auch entfernen, siehe Anmerkung unten
-
-- name: Setze globale Client-Key-Facts für alle Clients
-  set_fact:
-    wg_all_clients_private_keys: >-
-      {{
-        wg_all_clients_private_keys | default({}) | combine({
-          item.1.name: item.0.stdout
-        })
-      }}
-  loop: "{{ wg_client_private_keys.results | zip(wireguard_clients) | list }}"
-  delegate_to: localhost
-  run_once: true
-
-
-- name: Generiere Private Keys für Clients
-  command: "wg genkey"
-  register: client_keys_raw
-  loop: "{{ wireguard_clients }}"
-  loop_control:
-    loop_var: client
-  changed_when: false
-
-- name: Mappe Keys nach Namen
-  set_fact:
-    wg_all_clients_private_keys: "{{ dict(wireguard_clients | map(attribute='name') | list | zip(client_keys_raw.results | map(attribute='stdout') | list)) }}"
diff --git a/ansible/roles/wireguard/tasks/main.yml b/ansible/roles/wireguard/tasks/main.yml
deleted file mode 100644
index 9d52278b..00000000
--- a/ansible/roles/wireguard/tasks/main.yml
+++ /dev/null
@@ -1,22 +0,0 @@
-#- include_tasks: install.yml
-#- include_tasks: configure.yml
-#- include_tasks: generate_clients.yml
-#- include_tasks: firewall.yml
-
-
-- name: Installiere WireGuard
-  import_tasks: install.yml
-  when: ansible_connection != "local"
-
-- name: Konfiguriere WireGuard
-  import_tasks: configure.yml
-
-- name: Generiert .conf Dateien
-  import_tasks: generate_clients.yml
-
-- name: Setze Firewall-Regeln
-  import_tasks: firewall.yml
-  when: ansible_connection != "local"
-
-- name: Wende VPN-Failsafe-Regeln an
-  import_tasks: failsafe.yml
diff --git a/ansible/roles/wireguard/templates/client.conf.j2 b/ansible/roles/wireguard/templates/client.conf.j2
deleted file mode 100644
index c9c57564..00000000
--- a/ansible/roles/wireguard/templates/client.conf.j2
+++ /dev/null
@@ -1,10 +0,0 @@
-[Interface]
-PrivateKey = {{ wg_all_clients_private_keys[item.name] }}
-Address = {{ item.address }}/32
-DNS = 1.1.1.1
-
-[Peer]
-PublicKey = {{ item.public_key }}
-Endpoint = {{ wireguard_server_ip }}:{{ wireguard_port }}
-AllowedIPs = {{ wireguard_network }}, {{ wireguard_server_ip }}/32
-PersistentKeepalive = 25
diff --git a/ansible/roles/wireguard/templates/wg0.conf.j2 b/ansible/roles/wireguard/templates/wg0.conf.j2
deleted file mode 100644
index 98209837..00000000
--- a/ansible/roles/wireguard/templates/wg0.conf.j2
+++ /dev/null
@@ -1,12 +0,0 @@
-[Interface]
-Address = {{ wireguard_address }}
-PrivateKey = {{ wg_privkey | b64decode | trim }}
-ListenPort = {{ wireguard_port }}
-PostUp = iptables -A FORWARD -i {{ wireguard_interface }} -j ACCEPT; iptables -A FORWARD -o {{ wireguard_interface }} -j ACCEPT; iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE
-PostDown = iptables -D FORWARD -i {{ wireguard_interface }} -j ACCEPT; iptables -D FORWARD -o {{ wireguard_interface }} -j ACCEPT; iptables -t nat -D POSTROUTING -o eth0 -j MASQUERADE
-
-{% for client in wireguard_clients %}
-[Peer]
-PublicKey = {{ client.public_key }}
-AllowedIPs = {{ client.address }}/32
-{% endfor %}
diff --git a/ansible/wireguard-create-config.yml b/ansible/wireguard-create-config.yml
deleted file mode 100644
index 376f7145..00000000
--- a/ansible/wireguard-create-config.yml
+++ /dev/null
@@ -1,7 +0,0 @@
-# ansible/wireguard-create-config.yml
-- hosts: vpn
-  gather_facts: false
-  roles:
-    - role: wireguard
-      tasks_from: generate_clients # Zum Beispiel, je nach Task
-      # tasks_from: generate_client_single # Oder für einzelne Clients
diff --git a/ansible/wireguard-install-server.yml b/ansible/wireguard-install-server.yml
deleted file mode 100644
index 11bb3261..00000000
--- a/ansible/wireguard-install-server.yml
+++ /dev/null
@@ -1,9 +0,0 @@
-# ansible/wireguard-install-server.yml
-- hosts: vpn
-  become: true
-  gather_facts: true
-  roles:
-    - role: wireguard
-      tasks_from: install  # z.B., je nach Namensschema deiner Rolle
-    - role: wireguard
-      tasks_from: configure # Für Config/Firewall usw.
diff --git a/ansible/roles/wireguard/defaults/main.yml b/ansible/wireguard-server/roles/wireguard/defaults/main.yml
similarity index 100%
rename from ansible/roles/wireguard/defaults/main.yml
rename to ansible/wireguard-server/roles/wireguard/defaults/main.yml
diff --git a/ansible/wireguard-server/roles/wireguard/tasks/configure.yml b/ansible/wireguard-server/roles/wireguard/tasks/configure.yml
new file mode 100644
index 00000000..9c81de81
--- /dev/null
+++ b/ansible/wireguard-server/roles/wireguard/tasks/configure.yml
@@ -0,0 +1,126 @@
+---
+# WireGuard Server konfigurieren
+- name: Erstelle WireGuard-Verzeichnis
+  file:
+    path: /etc/wireguard
+    state: directory
+    mode: '0700'
+    owner: root
+    group: root
+
+- name: Erstelle Client-Config-Verzeichnis
+  file:
+    path: /etc/wireguard/clients
+    state: directory
+    mode: '0700'
+    owner: root
+    group: root
+
+# Server-Schlüssel verwalten
+- name: Prüfe ob Server-Schlüssel existieren
+  stat:
+    path: /etc/wireguard/server-private.key
+  register: server_private_key_stat
+
+- name: Generiere Server-Schlüssel
+  shell: |
+    wg genkey | tee /etc/wireguard/server-private.key | wg pubkey > /etc/wireguard/server-public.key
+    chmod 600 /etc/wireguard/server-private.key /etc/wireguard/server-public.key
+  when: not server_private_key_stat.stat.exists
+
+- name: Lese Server-Schlüssel
+  slurp:
+    src: /etc/wireguard/server-private.key
+  register: server_private_key_content
+
+- name: Lese Server-Public-Key
+  slurp:
+    src: /etc/wireguard/server-public.key
+  register: server_public_key_content
+
+- name: Setze Server-Schlüssel als Facts
+  set_fact:
+    wg_server_private_key: "{{ server_private_key_content.content | b64decode | trim }}"
+    wg_server_public_key: "{{ server_public_key_content.content | b64decode | trim }}"
+
+# Client-Schlüssel generieren
+- name: Generiere Client-Schlüssel
+  shell: |
+    cd /etc/wireguard/clients
+    if [ ! -f "{{ item.name }}-private.key" ]; then
+      wg genkey | tee "{{ item.name }}-private.key" | wg pubkey > "{{ item.name }}-public.key"
+      chmod 600 "{{ item.name }}-private.key" "{{ item.name }}-public.key"
+    fi
+  loop: "{{ wireguard_clients }}"
+
+# Generiere Pre-shared Keys
+- name: Generiere Pre-shared Keys für Clients
+  shell: |
+    cd /etc/wireguard/clients
+    if [ ! -f "{{ item.name }}-psk.key" ]; then
+      wg genpsk > "{{ item.name }}-psk.key"
+      chmod 600 "{{ item.name }}-psk.key"
+    fi
+  loop: "{{ wireguard_clients }}"
+  when: wireguard_pre_shared_key | default(false)
+
+# Lade alle Client-Keys
+- name: Lese Client-Private-Keys
+  slurp:
+    src: /etc/wireguard/clients/{{ item.name }}-private.key
+  loop: "{{ wireguard_clients }}"
+  register: client_private_keys
+
+- name: Lese Client-Public-Keys
+  slurp:
+    src: /etc/wireguard/clients/{{ item.name }}-public.key
+  loop: "{{ wireguard_clients }}"
+  register: client_public_keys
+
+- name: Lese Pre-shared Keys
+  slurp:
+    src: /etc/wireguard/clients/{{ item.name }}-psk.key
+  loop: "{{ wireguard_clients }}"
+  register: client_psk_keys
+  when: wireguard_pre_shared_key | default(false)
+
+# Erstelle Key-Dictionaries
+- name: Erstelle Client-Key-Dictionary
+  set_fact:
+    wg_client_private_keys: "{{ dict(wireguard_clients | map(attribute='name') | list | zip(client_private_keys.results | map(attribute='content') | map('b64decode') | map('trim') | list)) }}"
+    wg_client_public_keys: "{{ dict(wireguard_clients | map(attribute='name') | list | zip(client_public_keys.results | map(attribute='content') | map('b64decode') | map('trim') | list)) }}"
+
+- name: Erstelle Pre-shared Key Dictionary
+  set_fact:
+    wg_client_psk_keys: "{{ dict(wireguard_clients | map(attribute='name') | list | zip(client_psk_keys.results | map(attribute='content') | map('b64decode') | map('trim') | list)) }}"
+  when: 
+    - wireguard_pre_shared_key | default(false)
+    - client_psk_keys is defined
+
+# Server-Konfiguration erstellen
+- name: Erstelle WireGuard-Server-Konfiguration
+  template:
+    src: wg0.conf.j2
+    dest: /etc/wireguard/wg0.conf
+    mode: '0600'
+    owner: root
+    group: root
+  notify: restart wireguard
+
+# Client-Konfigurationen erstellen
+- name: Erstelle Client-Konfigurationen
+  template:
+    src: client.conf.j2
+    dest: /etc/wireguard/clients/{{ item.name }}.conf
+    mode: '0600'
+    owner: root
+    group: root
+  loop: "{{ wireguard_clients }}"
+
+# WireGuard-Service konfigurieren
+- name: Aktiviere WireGuard-Service
+  systemd:
+    name: wg-quick@wg0
+    enabled: true
+    state: started
+    daemon_reload: true
diff --git a/ansible/roles/wireguard/tasks/install.yml b/ansible/wireguard-server/roles/wireguard/tasks/install.yml
similarity index 60%
rename from ansible/roles/wireguard/tasks/install.yml
rename to ansible/wireguard-server/roles/wireguard/tasks/install.yml
index 69f7b13d..0a51c744 100644
--- a/ansible/roles/wireguard/tasks/install.yml
+++ b/ansible/wireguard-server/roles/wireguard/tasks/install.yml
@@ -1,7 +1,8 @@
-- name: Stelle sicher, dass WireGuard installiert ist
+---
+# Installiere WireGuard
+- name: Installiere WireGuard
   apt:
     name: wireguard
     state: present
     update_cache: yes
-  become: true
   when: ansible_connection != "local"
diff --git a/ansible/wireguard-server/roles/wireguard/tasks/main.yml b/ansible/wireguard-server/roles/wireguard/tasks/main.yml
new file mode 100644
index 00000000..1d601cb9
--- /dev/null
+++ b/ansible/wireguard-server/roles/wireguard/tasks/main.yml
@@ -0,0 +1,21 @@
+---
+- name: Prüfe erforderliche Variablen
+  assert:
+    that:
+      - wireguard_clients is defined
+      - wireguard_server_ip is defined
+      - wireguard_network is defined
+    fail_msg: "WireGuard-Konfiguration unvollständig: erforderliche Variablen nicht definiert"
+    success_msg: "WireGuard-Variablen korrekt definiert"
+  tags: [always]
+
+- name: Installiere WireGuard
+  import_tasks: install.yml
+  when: ansible_connection != "local"
+
+- name: Konfiguriere WireGuard
+  import_tasks: configure.yml
+
+- name: Konfiguriere Netzwerk für WireGuard
+  import_tasks: network.yml
+  when: ansible_connection != "local"
diff --git a/ansible/wireguard-server/roles/wireguard/templates/client.conf.j2 b/ansible/wireguard-server/roles/wireguard/templates/client.conf.j2
new file mode 100644
index 00000000..9ade6789
--- /dev/null
+++ b/ansible/wireguard-server/roles/wireguard/templates/client.conf.j2
@@ -0,0 +1,20 @@
+[Interface]
+PrivateKey = {{ wg_client_private_keys[item.name] }}
+Address = {{ item.address }}/32
+{% if wireguard_dns_servers is defined %}
+DNS = {{ wireguard_dns_servers | join(', ') }}
+{% endif %}
+{% if wireguard_mtu is defined %}
+MTU = {{ wireguard_mtu }}
+{% endif %}
+
+[Peer]
+PublicKey = {{ wg_server_public_key }}
+Endpoint = {{ wireguard_server_ip }}:{{ wireguard_port }}
+AllowedIPs = {{ wireguard_network }}
+{% if wireguard_keepalive is defined %}
+PersistentKeepalive = {{ wireguard_keepalive }}
+{% endif %}
+{% if wireguard_pre_shared_key | default(false) and wg_client_psk_keys is defined %}
+PresharedKey = {{ wg_client_psk_keys[item.name] }}
+{% endif %}
diff --git a/ansible/wireguard-server/roles/wireguard/templates/wg0.conf.j2 b/ansible/wireguard-server/roles/wireguard/templates/wg0.conf.j2
new file mode 100644
index 00000000..f66c3d18
--- /dev/null
+++ b/ansible/wireguard-server/roles/wireguard/templates/wg0.conf.j2
@@ -0,0 +1,28 @@
+[Interface]
+Address = {{ wireguard_address }}
+PrivateKey = {{ wg_server_private_key }}
+ListenPort = {{ wireguard_port }}
+{% if wireguard_mtu is defined %}
+MTU = {{ wireguard_mtu }}
+{% endif %}
+
+# Einfache NAT-Regeln für VPN-Traffic
+PostUp = iptables -t nat -I POSTROUTING -o {{ wireguard_exit_interface }} -s {{ wireguard_network }} -j MASQUERADE
+PostUp = iptables -I FORWARD -i {{ wireguard_interface }} -j ACCEPT
+PostUp = iptables -I FORWARD -o {{ wireguard_interface }} -j ACCEPT
+
+PostDown = iptables -t nat -D POSTROUTING -o {{ wireguard_exit_interface }} -s {{ wireguard_network }} -j MASQUERADE
+PostDown = iptables -D FORWARD -i {{ wireguard_interface }} -j ACCEPT
+PostDown = iptables -D FORWARD -o {{ wireguard_interface }} -j ACCEPT
+
+# Client-Peers
+{% for client in wireguard_clients %}
+[Peer]
+# {{ client.name }}
+PublicKey = {{ wg_client_public_keys[client.name] }}
+AllowedIPs = {{ client.address }}/32
+{% if wireguard_pre_shared_key | default(false) and wg_client_psk_keys is defined %}
+PresharedKey = {{ wg_client_psk_keys[client.name] }}
+{% endif %}
+
+{% endfor %}
diff --git a/ansible/wireguard-server/wireguard-create-config.yml b/ansible/wireguard-server/wireguard-create-config.yml
new file mode 100644
index 00000000..9df40404
--- /dev/null
+++ b/ansible/wireguard-server/wireguard-create-config.yml
@@ -0,0 +1,53 @@
+---
+- name: Create WireGuard Client Configurations
+  hosts: vpn
+  become: true
+  gather_facts: false
+  
+  tasks:
+    - name: Ensure client directory exists
+      file:
+        path: /etc/wireguard/clients
+        state: directory
+        mode: '0700'
+    
+    - name: Load existing server keys
+      slurp:
+        src: /etc/wireguard/server-public.key
+      register: server_pub_key
+    
+    - name: Set server public key fact
+      set_fact:
+        wg_server_public_key: "{{ server_pub_key.content | b64decode | trim }}"
+    
+    - name: Generate client configurations
+      include_role:
+        name: wireguard
+        tasks_from: configure
+      vars:
+        wg_server_public_key: "{{ server_pub_key.content | b64decode | trim }}"
+    
+    - name: List created client configurations
+      find:
+        paths: /etc/wireguard/clients
+        patterns: "*.conf"
+      register: client_configs
+    
+    - name: Show created configurations
+      debug:
+        msg: "Created client configurations: {{ client_configs.files | map(attribute='path') | map('basename') | list }}"
+    
+    - name: Generate QR codes for mobile clients
+      shell: qrencode -t ansiutf8 < /etc/wireguard/clients/{{ item.name }}.conf
+      loop: "{{ wireguard_clients }}"
+      register: qr_results
+      when: item.name is search('phone|mobile')
+      ignore_errors: true
+    
+    - name: Display QR codes
+      debug:
+        msg: |
+          QR Code for {{ item.item.name }}:
+          {{ item.stdout }}
+      loop: "{{ qr_results.results }}"
+      when: item.stdout is defined and not item.failed
diff --git a/ansible/wireguard-server/wireguard-install-server.yml b/ansible/wireguard-server/wireguard-install-server.yml
new file mode 100644
index 00000000..f34bffb4
--- /dev/null
+++ b/ansible/wireguard-server/wireguard-install-server.yml
@@ -0,0 +1,27 @@
+---
+- name: Install WireGuard Server
+  hosts: vpn
+  become: true
+  gather_facts: true
+  
+  pre_tasks:
+    - name: Update package cache
+      apt:
+        update_cache: true
+        cache_valid_time: 3600
+  
+  roles:
+    - role: wireguard
+      tags: [install, configure]
+
+  post_tasks:
+    - name: Show WireGuard status
+      command: wg show
+      register: wg_status
+      changed_when: false
+      ignore_errors: true
+    
+    - name: Display WireGuard status
+      debug:
+        var: wg_status.stdout_lines
+      when: wg_status.stdout is defined
diff --git a/bin/deploy b/bin/deploy
index 159a0a08..d113e3f5 100755
--- a/bin/deploy
+++ b/bin/deploy
@@ -1,4 +1,84 @@
 #!/bin/sh -l
 # Führt das Ansible-Deploy-Playbook aus
+#!/bin/bash
 
+# Deployment-Skript für verschiedene Umgebungen
+
+# Konfiguration
+ANSIBLE_INVENTORY="ansible/inventory/hosts.ini"
+PLAYBOOK_DIR="ansible/playbooks/deploy"
+
+# Farbdefinitionen
+GREEN="\033[0;32m"
+YELLOW="\033[1;33m"
+RED="\033[0;31m"
+NC="\033[0m" # No Color
+
+# Funktion zum Anzeigen von Nachrichten
+echo_msg() {
+    echo -e "${GREEN}[DEPLOY]${NC} $1"
+}
+
+echo_warn() {
+    echo -e "${YELLOW}[WARNUNG]${NC} $1"
+}
+
+echo_error() {
+    echo -e "${RED}[FEHLER]${NC} $1"
+}
+
+# Parameter auswerten
+ENVIRONMENT="$1"
+TAGS="$2"
+
+if [ -z "$ENVIRONMENT" ]; then
+    echo_warn "Keine Umgebung angegeben. Verfügbare Optionen:"
+    echo "  ./bin/deploy dev     - Lokale Entwicklungsumgebung"
+    echo "  ./bin/deploy staging - Staging-Umgebung"
+    echo "  ./bin/deploy prod    - Produktionsumgebung"
+    exit 1
+fi
+
+# Tags zusammenbauen (falls angegeben)
+TAGS_OPTION=""
+if [ -n "$TAGS" ]; then
+    TAGS_OPTION="--tags=$TAGS"
+    echo_msg "Verwende Tags: $TAGS"
+fi
+
+# Entsprechendes Playbook ausführen
+case "$ENVIRONMENT" in
+    dev|development|local)
+        echo_msg "Starte Deployment für lokale Entwicklungsumgebung..."
+        ansible-playbook -i "$ANSIBLE_INVENTORY" "$PLAYBOOK_DIR/dev.yml" --ask-become-pass $TAGS_OPTION
+        ;;
+    staging|stage)
+        echo_msg "Starte Deployment für Staging-Umgebung..."
+        ansible-playbook -i "$ANSIBLE_INVENTORY" "$PLAYBOOK_DIR/staging.yml" $TAGS_OPTION
+        ;;
+    prod|production)
+        echo_msg "Starte Deployment für Produktionsumgebung..."
+        read -p "Sind Sie sicher, dass Sie in der Produktionsumgebung deployen möchten? (j/N) " -n 1 -r
+        echo
+        if [[ $REPLY =~ ^[Jj]$ ]]; then
+            ansible-playbook -i "$ANSIBLE_INVENTORY" "$PLAYBOOK_DIR/production.yml" $TAGS_OPTION
+        else
+            echo_warn "Deployment in Produktionsumgebung abgebrochen."
+            exit 1
+        fi
+        ;;
+    *)
+        echo_error "Unbekannte Umgebung: $ENVIRONMENT"
+        exit 1
+        ;;
+esac
+
+# Deployment-Status prüfen
+if [ $? -eq 0 ]; then
+    echo_msg "Deployment erfolgreich abgeschlossen."
+    exit 0
+else
+    echo_error "Deployment fehlgeschlagen! Bitte überprüfen Sie die Logs."
+    exit 1
+fi
 /home/michael/.local/bin/ansible-playbook -i ansible/inventory.ini ansible/playbooks/deploy.yml
diff --git a/bin/generate-static.php b/bin/generate-static.php
new file mode 100644
index 00000000..2108e86b
--- /dev/null
+++ b/bin/generate-static.php
@@ -0,0 +1,87 @@
+#!/usr/bin/env php
+<?php
+declare(strict_types=1);
+
+use App\Framework\Core\AppBootstrapper;
+use App\Framework\StaticSite\StaticSiteGenerator;
+use App\Framework\StaticSite\StaticPageCollector;
+use App\Framework\Router\HttpRouter;
+
+require __DIR__ . '/../vendor/autoload.php';
+
+// CLI-Optionen verarbeiten
+$options = getopt('', ['manual-routes:', 'output:', 'exclude:', 'all', 'help']);
+
+if (isset($options['help'])) {
+    echo "Static Site Generator\n";
+    echo "---------------------\n\n";
+    echo "Optionen:\n";
+    echo "  --manual-routes=<datei>  Pfad zu einer JSON-Datei mit zu generierenden Routen (überschreibt Attributerkennung)\n";
+    echo "  --output=<ordner>        Ausgabeverzeichnis (Standard: public/static)\n";
+    echo "  --exclude=<muster>       Kommagetrennte Liste von Regex-Mustern für auszuschließende Routen\n";
+    echo "  --all                    Alle GET-Routen generieren (ignoriert #[StaticPage] Attribut)\n";
+    echo "  --help                   Diese Hilfe anzeigen\n";
+    exit(0);
+}
+
+// Konfiguration
+$config = [
+    'debug' => false,
+    'async_discovery' => true,
+    // weitere Konfigurationsoptionen...
+];
+
+// Anwendung initialisieren
+$basePath = dirname(__DIR__);
+$bootstrapper = new AppBootstrapper($basePath, $config);
+$app = $bootstrapper->bootstrap();
+
+// Verzeichnis für statische Seiten
+$outputDir = $options['output'] ?? $basePath . '/public/static';
+
+// Routen zum Generieren
+$routesToGenerate = [];
+
+// Ausschlussmuster verarbeiten
+$excludePatterns = [];
+if (isset($options['exclude'])) {
+    $patterns = explode(',', $options['exclude']);
+    foreach ($patterns as $pattern) {
+        $excludePatterns[] = '/' . trim($pattern) . '/';
+    }
+}
+
+// Prüfen, ob eine manuelle Routendatei angegeben wurde
+if (isset($options['manual-routes']) && file_exists($options['manual-routes'])) {
+    $routesToGenerate = json_decode(file_get_contents($options['manual-routes']), true) ?? [];
+    echo "Routen aus Datei geladen: " . count($routesToGenerate) . " Routen gefunden.\n";
+} elseif (isset($options['all'])) {
+    // Alle GET-Routen sammeln (ignoriert StaticPage-Attribut)
+    $router = $app->getContainer()->get(HttpRouter::class);
+    $staticPageCollector = new StaticPageCollector($router);
+    $allRoutes = $staticPageCollector->collectAllGetRoutes();
+    $routesToGenerate = $staticPageCollector->filterRoutes($allRoutes, $excludePatterns);
+    echo "Alle GET-Routen gesammelt: " . count($routesToGenerate) . " Routen gefunden.\n";
+} else {
+    // Routen mit StaticPage-Attribut sammeln
+    $router = $app->getContainer()->get(HttpRouter::class);
+    $staticPageCollector = new StaticPageCollector($router);
+    $staticRoutes = $staticPageCollector->collectStaticPages();
+    $routesToGenerate = $staticPageCollector->filterRoutes($staticRoutes, $excludePatterns);
+    echo "Routen mit #[StaticPage] Attribut gesammelt: " . count($routesToGenerate) . " Routen gefunden.\n";
+}
+
+if (empty($routesToGenerate)) {
+    echo "Keine Routen zum Generieren gefunden.\n";
+    echo "Füge das #[StaticPage] Attribut zu Controller-Methoden hinzu oder verwende --all, um alle Routen zu generieren.\n";
+    exit(1);
+}
+
+// Static Site Generator initialisieren und ausführen
+$generator = new StaticSiteGenerator($app, $routesToGenerate, $outputDir);
+
+// Statische Seiten generieren
+echo "Beginne mit der Generierung von statischen Seiten...\n";
+$generator->generate();
+
+echo "\nDie statischen Seiten wurden erfolgreich generiert im Verzeichnis: {$outputDir}\n";
diff --git a/bin/setup b/bin/setup
index 29c4ae0a..0707018f 100755
--- a/bin/setup
+++ b/bin/setup
@@ -1,3 +1,86 @@
-#!/bin/sh
-# Führt das Ansible-Deploy-Playbook aus
-/home/michael/.local/bin/ansible-playbook -i ansible/inventory.ini ansible/playbooks/setup.yml
+#!/bin/bash
+# Server-Setup-Skript für verschiedene Umgebungen
+#!/bin/bash
+
+# Server-Setup-Skript für verschiedene Umgebungen
+
+# Konfiguration
+ANSIBLE_INVENTORY="ansible/inventory/hosts.ini"
+SETUP_PLAYBOOK="ansible/setup.yml"
+
+# Farbdefinitionen
+GREEN="\033[0;32m"
+YELLOW="\033[1;33m"
+RED="\033[0;31m"
+NC="\033[0m" # No Color
+
+# Funktion zum Anzeigen von Nachrichten
+echo_msg() {
+    echo -e "${GREEN}[SETUP]${NC} $1"
+}
+
+echo_warn() {
+    echo -e "${YELLOW}[WARNUNG]${NC} $1"
+}
+
+echo_error() {
+    echo -e "${RED}[FEHLER]${NC} $1"
+}
+
+# Parameter auswerten
+ENVIRONMENT="$1"
+TAGS="$2"
+
+if [ -z "$ENVIRONMENT" ]; then
+    echo_warn "Keine Umgebung angegeben. Verfügbare Optionen:"
+    echo "  ./bin/setup staging - Staging-Server einrichten"
+    echo "  ./bin/setup prod    - Produktionsserver einrichten"
+    echo "  ./bin/setup all     - Alle Server einrichten"
+    exit 1
+fi
+
+# Tags zusammenbauen (falls angegeben)
+TAGS_OPTION=""
+if [ -n "$TAGS" ]; then
+    TAGS_OPTION="--tags=$TAGS"
+    echo_msg "Verwende Tags: $TAGS"
+fi
+
+# Limit für die Server-Auswahl
+LIMIT_OPTION=""
+case "$ENVIRONMENT" in
+    staging|stage)
+        LIMIT_OPTION="--limit=staging"
+        echo_msg "Richte Staging-Server ein..."
+        ;;
+    prod|production)
+        LIMIT_OPTION="--limit=production"
+        echo_msg "Richte Produktionsserver ein..."
+        read -p "Sind Sie sicher, dass Sie den Produktionsserver einrichten möchten? (j/N) " -n 1 -r
+        echo
+        if [[ ! $REPLY =~ ^[Jj]$ ]]; then
+            echo_warn "Einrichtung des Produktionsservers abgebrochen."
+            exit 1
+        fi
+        ;;
+    all)
+        echo_msg "Richte alle Server ein..."
+        ;;
+    *)
+        echo_error "Unbekannte Umgebung: $ENVIRONMENT"
+        exit 1
+        ;;
+esac
+
+# Setup-Playbook ausführen
+echo_msg "Führe Ansible-Playbook aus..."
+ansible-playbook -i "$ANSIBLE_INVENTORY" "$SETUP_PLAYBOOK" $LIMIT_OPTION $TAGS_OPTION
+
+# Setup-Status prüfen
+if [ $? -eq 0 ]; then
+    echo_msg "Server-Setup erfolgreich abgeschlossen."
+    exit 0
+else
+    echo_error "Server-Setup fehlgeschlagen! Bitte überprüfen Sie die Logs."
+    exit 1
+fi
diff --git a/build.sh b/build.sh
new file mode 100755
index 00000000..b12e3ee3
--- /dev/null
+++ b/build.sh
@@ -0,0 +1,61 @@
+#!/bin/bash
+set -e
+
+echo "🚀 Starting Docker build with network resilience..."
+
+# Prüfe Netzwerk-Konnektivität
+echo "🔍 Checking network connectivity..."
+if ! curl -s --connect-timeout 5 https://registry-1.docker.io/v2/ > /dev/null; then
+    echo "⚠️  Docker Hub nicht erreichbar - verwende lokale Images"
+    export DOCKER_BUILDKIT=0
+    export COMPOSE_DOCKER_CLI_BUILD=0
+fi
+
+# DNS-Cache leeren
+echo "🔄 Flushing DNS cache..."
+sudo systemctl flush-dns 2>/dev/null || sudo systemd-resolve --flush-caches 2>/dev/null || true
+
+# Docker daemon neu starten falls nötig
+if ! docker info > /dev/null 2>&1; then
+    echo "🔄 Restarting Docker daemon..."
+    sudo systemctl restart docker
+    sleep 5
+fi
+
+# Versuche erst mit Pull
+echo "📥 Attempting to pull base images..."
+if timeout 60 docker-compose pull --ignore-pull-failures; then
+    echo "✅ Images pulled successfully"
+else
+    echo "⚠️  Pull failed - building with local images only"
+fi
+
+# Build mit verschiedenen Strategien
+echo "🏗️  Building containers..."
+
+# Strategie 1: Normaler Build
+if timeout 300 docker-compose build --parallel; then
+    echo "✅ Build completed successfully!"
+    exit 0
+fi
+
+echo "⚠️  Normal build failed - trying fallback strategies..."
+
+# Strategie 2: Ohne Cache und Pull
+if timeout 300 docker-compose build --no-cache --pull=false; then
+    echo "✅ Build completed with fallback strategy!"
+    exit 0
+fi
+
+# Strategie 3: Sequenzieller Build
+echo "🔄 Trying sequential build..."
+for service in web php db redis queue-worker; do
+    echo "Building $service..."
+    if timeout 300 docker-compose build --no-cache --pull=false "$service"; then
+        echo "✅ $service built successfully"
+    else
+        echo "❌ Failed to build $service"
+    fi
+done
+
+echo "🏁 Build process completed"
diff --git a/composer.json b/composer.json
index cc1208cc..c0d03787 100644
--- a/composer.json
+++ b/composer.json
@@ -25,10 +25,16 @@
         }
     },
     "require": {
-        "predis/predis": "^3.0",
+      "predis/predis": "^3.0",
       "ext-dom": "*",
       "ext-libxml": "*",
-      "ext-curl": "*"
+      "ext-curl": "*",
+      "ext-pcntl": "*",
+      "ext-fileinfo": "*",
+      "ext-zlib": "*",
+      "ext-gd": "*",
+      "ext-pdo": "*",
+      "ext-apcu": "*"
     },
 
   "scripts": {
diff --git a/config/app.php b/config/app.php
index b3d9bbc7..de6bfcb8 100644
--- a/config/app.php
+++ b/config/app.php
@@ -1 +1,40 @@
 <?php
+
+return [
+    // Debug-Modus (aktiviert ausführliche Fehlerbehandlung)
+    'debug' => true,
+
+    // Discovery-Konfiguration
+    'async_discovery' => true,
+
+    // Standard-Middleware-Stack
+    'middleware' => [
+        // Globale Middleware für alle Requests
+        'global' => [
+            \App\Framework\Http\Middlewares\ControllerRequestMiddleware::class,
+            \App\Framework\Validation\ValidationErrorMiddleware::class,
+            \App\Framework\Http\Middlewares\RoutingMiddleware::class
+        ],
+
+        // Gruppen-spezifische Middleware
+        'api' => [
+            // Hier können Sie API-spezifische Middleware hinzufügen
+        ],
+
+        'web' => [
+            // Hier können Sie Web-spezifische Middleware hinzufügen
+        ]
+    ],
+
+    // Cache-Einstellungen
+    'cache' => [
+        'enabled' => true,
+        'ttl' => 3600, // Zeit in Sekunden
+    ],
+
+    // Logging-Einstellungen
+    'logging' => [
+        'level' => 'debug', // Optionen: debug, info, notice, warning, error, critical, alert, emergency
+        'path' => 'logs/app.log',
+    ],
+];
diff --git a/config/middleware.php b/config/middleware.php
new file mode 100644
index 00000000..5d7e5176
--- /dev/null
+++ b/config/middleware.php
@@ -0,0 +1,11 @@
+<?php
+
+use App\Framework\Http\Middleware\ServeStaticFilesMiddleware;
+
+return [
+    // Middleware wird in dieser Reihenfolge ausgeführt
+    'global' => [
+        ServeStaticFilesMiddleware::class,
+        // Weitere globale Middleware hier hinzufügen
+    ]
+];
diff --git a/config/services.php b/config/services.php
new file mode 100644
index 00000000..7f620e81
--- /dev/null
+++ b/config/services.php
@@ -0,0 +1,62 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Config;
+
+use App\Framework\DI\DefaultContainer;
+use App\Framework\Http\Middlewares\RateLimitingMiddleware;
+use App\Framework\Http\RateLimiter\RateLimiterConfig;
+use App\Framework\Http\RateLimiter\RedisRateLimiter;
+use Predis\Client as RedisClient;
+
+/**
+ * Konfiguriert die Dienste im DI-Container.
+ */
+return static function (DefaultContainer $container): void {
+    // Registrierung von Redis, wenn noch nicht vorhanden
+    if (!$container->has(RedisClient::class)) {
+        $container->bind(RedisClient::class, function () {
+            return new RedisClient([
+                'scheme' => $_ENV['REDIS_SCHEME'] ?? 'tcp',
+                'host' => $_ENV['REDIS_HOST'] ?? 'redis',
+                'port' => (int)($_ENV['REDIS_PORT'] ?? 6379),
+            ]);
+        });
+    }
+
+    // Rate Limiter Konfiguration
+    $container->bind(RateLimiterConfig::class, function () {
+        $config = new RateLimiterConfig(
+            defaultLimit: (int)($_ENV['RATE_LIMIT_DEFAULT'] ?? 60),
+            windowSeconds: (int)($_ENV['RATE_LIMIT_WINDOW'] ?? 60)
+        );
+
+        // Strengere Limits für sensible Bereiche
+        return $config
+            ->withAuthLimit((int)($_ENV['RATE_LIMIT_AUTH'] ?? 10), (int)($_ENV['RATE_LIMIT_AUTH_WINDOW'] ?? 300))
+            ->withApiLimit((int)($_ENV['RATE_LIMIT_API'] ?? 30), (int)($_ENV['RATE_LIMIT_API_WINDOW'] ?? 60))
+            // Weitere Limits hier hinzufügen...
+            ;
+    });
+
+    // Rate Limiter Service
+    $container->bind(RedisRateLimiter::class, function ($container) {
+        return new RedisRateLimiter(
+            $container->get(RedisClient::class)
+        );
+    });
+
+    // Rate Limiting Middleware
+    $container->bind(RateLimitingMiddleware::class, function ($container) {
+        $config = $container->get(RateLimiterConfig::class);
+        return new RateLimitingMiddleware(
+            $container->get(RedisClient::class),
+            $config->getDefaultLimit(),
+            $config->getWindowSeconds(),
+            $config->getPathLimits()
+        );
+    });
+
+    // Weitere Dienste hier registrieren...
+};
diff --git a/config/static-routes.json b/config/static-routes.json
new file mode 100644
index 00000000..2412e0fe
--- /dev/null
+++ b/config/static-routes.json
@@ -0,0 +1,10 @@
+[
+  "/",
+  "/about",
+  "/contact",
+  "/blog",
+  "/products",
+  "/services",
+  "/imprint",
+  "/privacy"
+]
diff --git a/console.php b/console.php
new file mode 100755
index 00000000..a7761463
--- /dev/null
+++ b/console.php
@@ -0,0 +1,27 @@
+#!/usr/bin/env php
+<?php
+declare(strict_types=1);
+
+require_once __DIR__ . '/vendor/autoload.php';
+require __DIR__ . '/src/Framework/Debug/helpers.php';
+
+use App\Framework\Console\ConsoleApplication;
+use App\Framework\Console\DemoCommand;
+use App\Framework\Core\AppBootstrapper;
+use App\Framework\Performance\PerformanceMeter;
+
+$bootstrapper = new AppBootstrapper(__DIR__, new PerformanceMeter());
+
+try {
+
+    $exitCode = $bootstrapper->bootstrapConsole()->run($argv);
+    exit($exitCode);
+
+} catch (Throwable $e) {
+    echo "\033[31mFehler: " . $e->getMessage() . "\033[0m" . PHP_EOL;
+    exit(1);
+}
+
+/*
+ * docker exec php php console.php
+ */
diff --git a/deploy.sh b/deploy.sh
new file mode 100644
index 00000000..ec87eeca
--- /dev/null
+++ b/deploy.sh
@@ -0,0 +1,69 @@
+#!/bin/bash
+
+# Konfiguration
+SERVER_USER="deploy"
+SERVER_IP="94.16.110.151"
+REMOTE_PATH="/var/www/michaelschiemer"
+LOCAL_PATH="."
+EXCLUDES="--exclude=.git --exclude=node_modules --exclude=vendor --exclude=.env"
+SSH_OPTS="-o StrictHostKeyChecking=no"
+
+# Farben für Ausgabe
+GREEN="\e[32m"
+YELLOW="\e[33m"
+RED="\e[31m"
+RESET="\e[0m"
+
+echo -e "${YELLOW}Deployment auf ${SERVER_IP} starten...${RESET}"
+
+# 1. Temporäres Verzeichnis erstellen
+TMP_DIR=$(mktemp -d)
+echo -e "${YELLOW}Temporäres Verzeichnis erstellt: ${TMP_DIR}${RESET}"
+
+# 2. Dateien in temporäres Verzeichnis kopieren (ohne Ausschlüsse)
+echo -e "${YELLOW}Kopiere Projektdateien...${RESET}"
+rsync -a $EXCLUDES "$LOCAL_PATH/" "$TMP_DIR/"
+
+# 3. Archiv erstellen
+echo -e "${YELLOW}Erstelle Archiv...${RESET}"
+TMP_ARCHIVE="/tmp/project-$(date +%Y%m%d-%H%M%S).tar.gz"
+tar -czf "$TMP_ARCHIVE" -C "$TMP_DIR" .
+
+# 4. Verzeichnisse auf dem Server erstellen
+echo -e "${YELLOW}Erstelle Verzeichnisse auf dem Server...${RESET}"
+ssh $SSH_OPTS "$SERVER_USER@$SERVER_IP" "mkdir -p $REMOTE_PATH"
+
+# 5. Archiv auf den Server übertragen
+echo -e "${YELLOW}Übertrage Dateien auf den Server...${RESET}"
+scp $SSH_OPTS "$TMP_ARCHIVE" "$SERVER_USER@$SERVER_IP:/tmp/project.tar.gz"
+
+# 6. Archiv auf dem Server entpacken
+echo -e "${YELLOW}Entpacke Dateien auf dem Server...${RESET}"
+ssh $SSH_OPTS "$SERVER_USER@$SERVER_IP" "tar -xzf /tmp/project.tar.gz -C $REMOTE_PATH"
+
+# 7. Umgebungsdatei erstellen, falls nicht vorhanden
+echo -e "${YELLOW}Überprüfe/erstelle .env Datei...${RESET}"
+ssh $SSH_OPTS "$SERVER_USER@$SERVER_IP" "[ -f $REMOTE_PATH/.env ] || cp $REMOTE_PATH/.env.example $REMOTE_PATH/.env"
+
+# 8. Berechtigungen setzen
+echo -e "${YELLOW}Setze Berechtigungen...${RESET}"
+ssh $SSH_OPTS "$SERVER_USER@$SERVER_IP" "chmod -R 775 $REMOTE_PATH/storage $REMOTE_PATH/cache"
+
+# 9. Abhängigkeiten installieren und Build ausführen
+echo -e "${YELLOW}Installiere Abhängigkeiten und baue Assets...${RESET}"
+ssh $SSH_OPTS "$SERVER_USER@$SERVER_IP" "cd $REMOTE_PATH && composer install --no-dev && npm ci && npm run build"
+
+# 10. Docker Container neu starten
+echo -e "${YELLOW}Starte Docker Container neu...${RESET}"
+ssh $SSH_OPTS "$SERVER_USER@$SERVER_IP" "cd $REMOTE_PATH && docker compose up -d"
+
+# 11. Aufräumen
+echo -e "${YELLOW}Räume auf...${RESET}"
+rm -rf "$TMP_DIR" "$TMP_ARCHIVE"
+ssh $SSH_OPTS "$SERVER_USER@$SERVER_IP" "rm /tmp/project.tar.gz"
+
+echo -e "${GREEN}Deployment abgeschlossen!${RESET}"
+echo -e "${YELLOW}Docker Container Status:${RESET}"
+ssh $SSH_OPTS "$SERVER_USER@$SERVER_IP" "cd $REMOTE_PATH && docker compose ps"
+
+exit 0
diff --git a/docker-compose.yml b/docker-compose.yml
index f7b42311..14ca363f 100644
--- a/docker-compose.yml
+++ b/docker-compose.yml
@@ -1,99 +1,166 @@
-x-docker-settings: &docker-settings
-  build:
-    context: .
-    args:
-      - BUILDKIT_INLINE_CACHE=1
-
-services:
-  web:
-    build:
-      context: ./docker/nginx
-      dockerfile: Dockerfile
-    ports:
-      - "${APP_PORT:-8000}:80"
-      - "127.0.0.1:8080:80"
-      - "${APP_SSL_PORT:-443}:443"
-    environment:
-      - APP_ENV=${APP_ENV:-development}
-    volumes:
-      - ./:/var/www/html:cached
-      - ./ssl:/etc/nginx/ssl:ro  # SSL-Zertifikate mounten
-    depends_on:
-      php:
-        condition: service_started
-    restart: unless-stopped
-    networks:
-      - frontend
-      - backend
-    env_file:
-      - .env
-
-  php:
-    container_name: php
-    build:
-      context: .
-      dockerfile: docker/php/Dockerfile
-      args:
-        - ENV=${APP_ENV:-dev}
-        - COMPOSER_INSTALL_FLAGS=${COMPOSER_INSTALL_FLAGS:---no-scripts --no-autoloader}
-
-    volumes:
-      # Shared Volume für Composer-Cache über Container-Neustarts hinweg
-      - composer-cache:/root/.composer/cache
-      # Bindet das Projektverzeichnis für Live-Änderungen ein
-      - ./:/var/www/html:cached
-      # Verhindert Überschreiben der Vendor-Verzeichnisse
-      #- /var/www/html/vendor
-
-      #- cache-volume:/var/www/html/cache:rw
-    environment:
-      PHP_IDE_CONFIG: "serverName=docker"
-      APP_ENV: ${APP_ENV:-development}
-
-    healthcheck:
-      test: [ "CMD", "php", "-v" ]
-      interval: 10s
-      timeout: 5s
-      retries: 5
-
-    restart: unless-stopped
-    networks:
-      - backend
-      #- cache
-#      backend:
-#        aliases:
-#          - php
-#      cache:
-    env_file:
-      - .env
-
-  redis:
-    image: redis:8-alpine
-    volumes:
-      - ./docker/redis/redis.conf:/usr/local/etc/redis/redis.conf
-      - redis_data:/data
-    command: ["redis-server", "/usr/local/etc/redis/redis.conf"]
-    healthcheck:
-      test: ["CMD", "redis-cli", "ping"]
-      interval: 30s
-      timeout: 5s
-      retries: 3
-
-    restart: unless-stopped
-    networks:
-      - cache
-    env_file:
-      - .env
-
-networks:
-  frontend:
-    driver: bridge
-  backend:
-    driver: bridge
-  cache:
-    driver: bridge
-
-volumes:
-  redis_data:
-  composer-cache:
-  #cache-volume:
+services:
+  web:
+    container_name: web
+    build:
+      context: docker/nginx
+      dockerfile: Dockerfile
+    ports:
+      - "${APP_PORT:-8000}:80"
+      - "127.0.0.1:8080:80"
+      - "${APP_SSL_PORT:-443}:443/tcp"
+      - "443:443/udp"
+    environment:
+      - APP_ENV=${APP_ENV:-development}
+    healthcheck:
+      test: ["CMD", "curl", "-f", "https://localhost/"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+      start_period: 10s
+    volumes:
+      - ./:/var/www/html:cached
+      #- ./ssl:/etc/nginx/ssl:ro  # SSL-Zertifikate mounten
+      - ./ssl:/var/www/ssl:ro
+    depends_on:
+      php:
+        condition: service_started
+    restart: unless-stopped
+    networks:
+      - frontend
+      - backend
+    env_file:
+      - .env
+
+  php:
+    container_name: php
+    build:
+      context: .
+      dockerfile: docker/php/Dockerfile
+      args:
+        - ENV=${APP_ENV:-dev}
+        - COMPOSER_INSTALL_FLAGS=${COMPOSER_INSTALL_FLAGS:---no-scripts --no-autoloader}
+    user: "1000:1000"
+    logging:
+      driver: "local"
+      options:
+        max-size: "5m"
+        max-file: "2"
+    volumes:
+      # Shared Volume für Composer-Cache über Container-Neustarts hinweg
+      - composer-cache:/root/.composer/cache
+      # Bindet das Projektverzeichnis für Produktivbetrieb  ein
+      #- project-data:/var/www/html:cached
+      # Variante mit mounting:
+      - ./:/var/www/html:cached
+      # Verhindert Überschreiben der Vendor-Verzeichnisse
+      #- /var/www/html/vendor
+      #- cache-volume:/var/www/html/cache:rw
+    environment:
+      PHP_IDE_CONFIG: "serverName=docker"
+      APP_ENV: ${APP_ENV:-development}
+    healthcheck:
+      test: [ "CMD", "php", "-v" ]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+    restart: unless-stopped
+    networks:
+      - backend
+      - cache
+    env_file:
+      - .env
+
+  db:
+    container_name: db
+    image: mariadb:latest
+    restart: unless-stopped
+    environment:
+      MYSQL_ROOT_PASSWORD: qwee65132ertert  # ändere das bitte!
+      MYSQL_DATABASE: database              # optionale Initial-Datenbank
+      MYSQL_USER: mdb-user                  # optionaler zusätzlicher User
+      MYSQL_PASSWORD: dfghreh5465fghfgh     # Passwort für den zusätzlichen User
+    ports:
+      - "33060:3306"
+    volumes:
+      - db_data:/var/lib/mysql
+    healthcheck:
+      test: [ "CMD", "mariadb-admin", "ping", "-h", "127.0.0.1", "-u", "root", "-pqwee65132ertert" ]
+      interval: 10s
+      timeout: 5s
+      retries: 5
+      start_period: 30s
+    networks:
+      - backend
+
+  redis:
+    container_name: redis
+    image: redis:8-alpine
+    volumes:
+      - ./docker/redis/redis.conf:/usr/local/etc/redis/redis.conf
+      - redis_data:/data
+    command: ["redis-server", "/usr/local/etc/redis/redis.conf"]
+    healthcheck:
+      test: ["CMD", "redis-cli", "ping"]
+      interval: 30s
+      timeout: 5s
+      retries: 3
+    restart: unless-stopped
+    networks:
+      - cache
+    env_file:
+      - .env
+
+  queue-worker:
+    container_name: queue-worker
+    build:
+      context: .
+      dockerfile: docker/worker/Dockerfile
+    # user: "1000:1000"  # Same user ID as PHP container
+    depends_on:
+      php:
+        condition: service_healthy
+      redis:
+        condition: service_healthy
+      db:
+        condition: service_healthy
+    volumes:
+      - ./:/var/www/html:cached
+      - ./storage/logs:/var/www/html/storage/logs:rw
+      - ./src/Framework/CommandBus/storage:/var/www/html/src/Framework/CommandBus/storage:rw
+    environment:
+      - APP_ENV=${APP_ENV:-development}
+      - WORKER_DEBUG=${WORKER_DEBUG:-false}
+      - WORKER_SLEEP_TIME=${WORKER_SLEEP_TIME:-100000}
+      - WORKER_MAX_JOBS=${WORKER_MAX_JOBS:-1000}
+    restart: unless-stopped
+    networks:
+      - backend
+      - cache
+    env_file:
+      - .env
+    # Graceful shutdown timeout
+    stop_grace_period: 30s
+    # Resource limits for the worker
+    deploy:
+      resources:
+        limits:
+          memory: 512M
+        reservations:
+          memory: 256M
+
+networks:
+  frontend:
+    driver: bridge
+  backend:
+    driver: bridge
+  cache:
+    driver: bridge
+
+volumes:
+  redis_data:
+  composer-cache:
+  #cache-volume:
+  db_data:
+  project-data:
+  worker-logs:
+  worker-queue:
diff --git a/docker/DOCKER-TODO.md b/docker/DOCKER-TODO.md
new file mode 100644
index 00000000..ac49566d
--- /dev/null
+++ b/docker/DOCKER-TODO.md
@@ -0,0 +1,48 @@
+# Optimierungsvorschläge für die Docker-Compose Umgebung
+
+## ToDo-Liste
+
+- [ ] **Datenbank Passwörter & Secrets absichern**
+  - Datenbankpasswörter nicht im Klartext in der YAML speichern, sondern `secrets`-Mechanismus verwenden.
+  - `.env` Werte für Datenbanken statt statischer Angaben verwenden.
+  - Beispiel: `MYSQL_ROOT_PASSWORD_FILE` und `MYSQL_PASSWORD_FILE` setzen und Secrets einbinden.
+
+- [ ] **Performance & Caching verbessern**
+  - `cache_from` und `cache_to` im Build-Prozess (BuildKit) einrichten.
+  - Für PHP einen dedizierten Volume für den Composer-Cache nutzen.
+  - Nginx-Cache als eigenes Volume deklarieren.
+  - Die Vendor-Ordner aus Mounts ausschließen oder gesondert berücksichtigen, damit lokale Änderungen keine Build-Optimierungen verhindern.
+
+- [ ] **Netzwerk- und Bind-Mounts optimieren**
+  - Bei Nginx nur das Public-Verzeichnis (`public/`) einbinden, nicht das gesamte Projektverzeichnis.
+  - Nicht benötigte Verzeichnisse (wie z.B. `vendor/`) explizit ausschließen.
+  - Healthchecks und Startbedingungen konsistent definieren.
+
+- [ ] **Image-Versionen festlegen**
+  - Keine `latest`-Images nutzen, sondern möglichst immer eine feste Version angeben (z.B. `mariadb:11.3` statt `mariadb:latest`).
+  - Gilt auch für Redis, PHP und weitere Services.
+
+- [ ] **Ressourcenlimits setzen**
+  - `deploy.resources` für Speicher und CPU bei allen Services, nicht nur beim Worker.
+
+- [ ] **Security-Best-Practices**
+  - Nicht produktive Ports (z.B. bei Entwicklung) durch `.env` variabel und gezielt auf localhost begrenzen.
+  - Feste Netzwerkbereiche und eigene Netzwerke für sensible Kommunikation (z.B. Backend, Cache).
+
+- [ ] **Multi-Stage Builds in Dockerfiles nutzen**
+  - Die Images im PHP- und Worker-Bereich sollten über Multi-Stage-Builds möglichst klein gehalten werden (z.B. `FROM php:X-cli AS base`, dann Production-Image).
+
+- [ ] **Environment-Konfiguration für Dev/Prod trennen**
+  - Eine `docker-compose.override.yml` für Entwicklung mit vollem Source-Mount und Debug-Konfiguration anlegen.
+  - Für Produktion keine Source-Mounts, keine Debug-Variablen, optimierte Settings.
+
+- [ ] **Log-Rotation aktivieren**
+  - Logging-Driver auf `json-file` einstellen und Optionen für Größe/Rotation setzen.
+
+- [ ] **Monitoring & Healthchecks**
+  - Für alle Services sinnvolle Healthchecks ergänzen.
+  - (Optional) Monitoring und/oder Alerting ergänzen.
+
+---
+
+**Tipp:** Die oben stehenden Punkte können Schritt für Schritt umgesetzt und pro optimiertem Bereich abgehakt werden.
diff --git a/docker/nginx/Dockerfile b/docker/nginx/Dockerfile
index fb9af359..0705b114 100644
--- a/docker/nginx/Dockerfile
+++ b/docker/nginx/Dockerfile
@@ -1,33 +1,73 @@
-FROM nginx:alpine
+FROM macbre/nginx-http3
 
-# Standard-Konfiguration entfernen
-RUN rm /etc/nginx/conf.d/default.conf
+# Zurück zu root wechseln
+USER root
 
-# Verzeichnisse erstellen mit korrekten Berechtigungen
-RUN mkdir -p /var/cache/nginx /var/log/nginx /etc/nginx/template && \
-    chmod -R 777 /var/cache/nginx /var/log/nginx
+# Entferne Default-Site
+RUN rm -f /etc/nginx/conf.d/default.conf || true
 
-# Kopiere die Template-Konfiguration
+# Verzeichnisse erstellen
+RUN mkdir -p /var/cache/nginx /var/log/nginx /var/www/ssl && \
+    chmod 755 /var/cache/nginx /var/log/nginx /var/www/ssl
+
+# Konfigurationen kopieren
 COPY ./nginx.conf /etc/nginx/nginx.conf
 COPY ./default.conf /etc/nginx/conf.d/default.conf
+COPY ./ssl/ /var/www/ssl/
 
-# Kopiere die SSL-Zertifikate
-COPY ./ssl/ /etc/nginx/ssl/
+# Entry-Script kopieren
+COPY ./docker-entrypoint.sh /usr/local/bin/docker-entrypoint.sh
+RUN chmod +x /usr/local/bin/docker-entrypoint.sh
 
-# Startup-Skript zum Ersetzen der Variablen
-COPY ./docker-entrypoint.sh /
-RUN chmod +x /docker-entrypoint.sh
+# su-exec und netcat installieren
+RUN apk add --no-cache su-exec netcat-openbsd
 
-#Install Netcat
-RUN apk add --no-cache netcat-openbsd
+# Berechtigungen für stdout/stderr anpassen
+RUN chmod a+rw /dev/stdout /dev/stderr
 
-
-# Als user www-data laufen lassen
-RUN addgroup -g 1000 www && adduser -D -G www -u 1000 www-data \
- && chown -R www-data:www /var/cache/nginx /var/log/nginx /etc/nginx
-USER www-data
+# Ordner-Berechtigungen für den nginx-User setzen
+RUN chown -R nginx:nginx /var/cache/nginx /var/log/nginx /var/www/ssl
 
 EXPOSE 80 443
 
-ENTRYPOINT ["/docker-entrypoint.sh"]
-CMD ["nginx", "-g", "daemon off;"]
+ENTRYPOINT ["/usr/local/bin/docker-entrypoint.sh"]
+#CMD ["nginx", "-g", "daemon off;"]
+
+
+
+
+
+## Standard-Konfiguration entfernen
+#RUN rm -f /etc/nginx/conf.d/default.conf
+#
+## Verzeichnisse erstellen mit korrekten Berechtigungen
+#RUN mkdir -p /var/cache/nginx /var/log/nginx /etc/nginx/template && \
+#    chmod -R 777 /var/cache/nginx /var/log/nginx
+#
+## Kopiere die Template-Konfiguration
+#COPY ./nginx.conf /etc/nginx/nginx.conf
+#COPY ./default.conf /etc/nginx/conf.d/default.conf
+#
+## Kopiert config Include
+#COPY ./vite-proxy.inc.dev /etc/nginx/vite-proxy.inc
+#
+## Kopiere die SSL-Zertifikate
+#COPY ./ssl/ /etc/nginx/ssl/
+#
+## Startup-Skript zum Ersetzen der Variablen
+#COPY ./docker-entrypoint.sh /
+#RUN chmod +x /docker-entrypoint.sh
+#
+##Install Netcat
+#RUN apk add --no-cache netcat-openbsd
+#
+#
+## Als user www-data laufen lassen
+#RUN addgroup -g 1000 www && adduser -D -G www -u 1000 www-data \
+# && chown -R www-data:www /var/cache/nginx /var/log/nginx /etc/nginx
+#USER www-data
+#
+#EXPOSE 80 443
+#
+#ENTRYPOINT ["/docker-entrypoint.sh"]
+#CMD ["nginx", "-g", "daemon off;"]
diff --git a/docker/nginx/default.conf b/docker/nginx/default.conf
index 7b7b379c..966289a7 100644
--- a/docker/nginx/default.conf
+++ b/docker/nginx/default.conf
@@ -18,8 +18,8 @@ map $env_mode $should_skip_cache {
 
 # Skip-Cache für Sessions und basierend auf Umgebung
 map $http_cookie$should_skip_cache $skip_cache {
-    "~PHPSESSID"  1;       # Sessions nie cachen
-    "1"           1;       # Cache überspringen, wenn should_skip_cache = 1
+    "~ms_context"  1;       # Sessions nie cachen
+    "~1$"           1;       # Cache überspringen, wenn should_skip_cache = 1
     default       0;       # Ansonsten cachen
 }
 
@@ -41,23 +41,38 @@ server {
 server {
     # Korrigierte HTTP/2 Syntax
     listen 443 ssl;
+    listen [::]:443 ssl;
+    listen 443 quic; # QUIC für HTTP/3 // Removed "reuseport"
+    listen [::]:443 quic;
+
     http2 on;  # Neue Syntax für HTTP/2
+    http3 on;
+
+    add_header Alt-Svc 'h3=":443"; ma=86400; persist=1, h2=":443"; ma=86400';
+
     server_name localhost;
 
     #ssl_certificate /etc/nginx/ssl/localhost+2.pem;
     #ssl_certificate_key /etc/nginx/ssl/localhost+2-key.pem;
-    ssl_certificate /etc/nginx/ssl/fullchain.pem;
-    ssl_certificate_key /etc/nginx/ssl/privkey.pem;
+    #ssl_certificate /etc/nginx/ssl/fullchain.pem;
+    #ssl_certificate_key /etc/nginx/ssl/privkey.pem;
+
+    ssl_certificate /var/www/ssl/fullchain.pem;
+    ssl_certificate_key /var/www/ssl/privkey.pem;
 
 
-    ssl_protocols TLSv1.2 TLSv1.3;
+    # add_header Alt-Svc 'h3=":443"'; # Für HTTP/3 Unterstützung
+    #add_header QUIC-Status $quic;
+
+
+    ssl_protocols TLSv1.3 TLSv1.2;
     ssl_prefer_server_ciphers on;
     ssl_ciphers ECDHE-RSA-AES256-GCM-SHA512:DHE-RSA-AES256-GCM-SHA512:ECDHE-RSA-AES256-GCM-SHA384:DHE-RSA-AES256-GCM-SHA384;
 
     # Verbesserte SSL-Konfiguration
-    ssl_session_timeout 1d;
-    ssl_session_cache shared:SSL:10m;
-    ssl_session_tickets off;
+    #ssl_session_timeout 1d;
+    #ssl_session_cache shared:SSL:10m;
+    #ssl_session_tickets off;
 
     # OCSP Stapling (auskommentiert, wenn Zertifikate fehlen)
     # ssl_stapling on;
@@ -68,6 +83,11 @@ server {
     root /var/www/html/public;
     index index.php index.html;
 
+    location / {
+        try_files $uri $uri/ /index.php?$query_string;
+        autoindex off;
+    }
+
     # Debug-Header für die Entwicklung
     add_header X-Environment $env_mode always;
 
@@ -88,6 +108,34 @@ server {
     client_max_body_size 10m;
     large_client_header_buffers 2 1k;
 
+    brotli on;
+    brotli_comp_level 6;
+    brotli_types
+        application/atom+xml
+        application/javascript
+        application/json
+        application/ld+json
+        application/manifest+json
+        application/rss+xml
+        application/vnd.geo+json
+        application/vnd.ms-fontobject
+        application/x-font-ttf
+        application/x-web-app-manifest+json
+        application/xhtml+xml
+        application/xml
+        font/opentype
+        image/bmp
+        image/svg+xml
+        image/x-icon
+        text/cache-manifest
+        text/css
+        text/plain
+        text/vcard
+        text/vnd.rim.location.xloc
+        text/vtt
+        text/x-componentFs
+        text/x-cross-domain-policy;
+
     # Verbesserte Gzip-Kompression
     gzip on;
     gzip_vary on;
@@ -119,33 +167,43 @@ server {
         text/vcard
         text/vnd.rim.location.xloc
         text/vtt
-        text/x-component
+        text/x-componentFs
         text/x-cross-domain-policy;
 
     # Logs
-    access_log /var/log/nginx/access.log combined;
-    error_log /var/log/nginx/error.log error;
+    #access_log /var/log/nginx/access.log combined;
+    #error_log /var/log/nginx/error.log error;
+    access_log /dev/stdout;
+    error_log /dev/stderr warn;
 
-    location / {
-        try_files $uri $uri/ /index.php?$query_string;
-        autoindex off;
+    # läuft aktuell oben über dynamischen include!
+    #location / {
+    #    try_files $uri $uri/ /index.php?$query_string;
+    #    autoindex off;
+    #}
+
+    # Service-Worker explizit erlauben (auch im Production-Server ungefährlich!)
+    location = /sw.js {
+        # je nach Build-Ordner anpassen!
+        alias /var/www/html/public/sw.js;
+        add_header Cache-Control "no-cache, must-revalidate";
     }
 
     # Caching Header für statische Dateien
-    location ~* \.(jpg|jpeg|png|gif|ico|svg|woff|woff2|ttf|eot)$ {
-        expires 1y;
-        add_header Cache-Control "public, immutable, max-age=31536000";
-    }
+    #location ~* \.(jpg|jpeg|png|gif|ico|svg|woff|woff2|ttf|eot)$ {
+    #    expires 1y;
+    #    add_header Cache-Control "public, immutable, max-age=31536000";
+    #}
 
     location ~* \.(css|js)$ {
         expires 1w;
         add_header Cache-Control "public, max-age=604800";
     }
 
-    location ~* \.(json|xml)$ {
-        expires 1d;
-        add_header Cache-Control "public, max-age=86400";
-    }
+#     location ~* \.(json|xml)$ {
+#         expires 1d;
+#         add_header Cache-Control "public, max-age=86400";
+#     }
 
     location ~ \.php$ {
         try_files $uri =404;
@@ -182,6 +240,8 @@ server {
 
         # Für bessere Performance
         fastcgi_keep_conn on;
+
+        fastcgi_hide_header X-Powered-By;
     }
 
     # Sicherheitseinstellungen
diff --git a/docker/nginx/docker-entrypoint.sh b/docker/nginx/docker-entrypoint.sh
index 2ec3a5f4..d7641c97 100644
--- a/docker/nginx/docker-entrypoint.sh
+++ b/docker/nginx/docker-entrypoint.sh
@@ -1,20 +1,58 @@
 #!/bin/sh
 set -e
+#!/bin/sh
+set -e
 
+# Umgebungsvariablen-Substitution in Nginx-Konfiguration
+if [ -n "$APP_ENV" ]; then
+    echo "Setting APP_ENV to: $APP_ENV"
+    sed -i "s/\${APP_ENV}/$APP_ENV/g" /etc/nginx/conf.d/default.conf
+fi
+
+# Warte auf PHP-FPM Container
+echo "Waiting for PHP-FPM to be ready..."
+while ! nc -z php 9000; do
+    sleep 1
+done
+echo "PHP-FPM is ready!"
+
+# SSL-Zertifikate prüfen
+if [ ! -f "/var/www/ssl/fullchain.pem" ] || [ ! -f "/var/www/ssl/privkey.pem" ]; then
+    echo "Warning: SSL certificates not found. HTTPS may not work properly."
+fi
+
+# Nginx-Konfiguration testen
+echo "Testing Nginx configuration..."
+nginx -t
+
+# Nginx starten
+echo "Starting Nginx..."
+exec "$@"
 until nc -z -w 2 php 9000; do
   echo "Warte auf PHP-FPM..."
   sleep 1
 done
 
-
 # Optional: eigene Umgebungsvariable mit Default setzen
 export APP_ENV="${APP_ENV:-production}"
 
 echo "Starte Nginx mit APP_ENV=$APP_ENV"
 
-# Ersetze Umgebungsvariablen wie ${APP_ENV} in der Nginx-Config per envsubst
-envsubst '${APP_ENV}' < /etc/nginx/conf.d/default.conf > /etc/nginx/conf.d/default.conf.tmp
-mv /etc/nginx/conf.d/default.conf.tmp /etc/nginx/conf.d/default.conf
+# Ersetze Platzhalter in temporäre Datei
+envsubst '${APP_ENV}' < /etc/nginx/conf.d/default.conf > /tmp/default.conf
 
-# Starte Nginx (Foreground)
+# Ersetzte Originalkonfiguration
+cp /tmp/default.conf /etc/nginx/conf.d/default.conf
+
+# WICHTIG: Rechte für stdout/stderr anpassen
+chmod a+rw /dev/stdout /dev/stderr
+
+# Nginx-Ordner Rechte anpassen
+mkdir -p /var/cache/nginx /var/log/nginx
+chown -R nginx:nginx /var/cache/nginx /var/log/nginx
+
+# Stelle sicher, dass das SSL-Verzeichnis existiert
+mkdir -p /var/www/ssl
+
+# Jetzt kann nginx sicher starten
 exec nginx -g 'daemon off;'
diff --git a/docker/nginx/nginx.conf b/docker/nginx/nginx.conf
index 1a675e65..3415cddb 100644
--- a/docker/nginx/nginx.conf
+++ b/docker/nginx/nginx.conf
@@ -1,37 +1,78 @@
+# Standard Nginx User
+user nginx;
 worker_processes auto;
-pid /tmp/nginx.pid;
+error_log /var/log/nginx/error.log notice;
+pid /var/run/nginx.pid;
 
+# Worker-Prozess-Einstellungen
 events {
     worker_connections 1024;
+    use epoll;
+    multi_accept on;
 }
 
 http {
+    # MIME-Types
     include /etc/nginx/mime.types;
     default_type application/octet-stream;
 
+    # Server-Tokens für Sicherheit ausblenden
     server_tokens off;
 
-    # Rate-Limiting für besseren DDoS-Schutz
+    # Rate-Limiting
     limit_req_zone $binary_remote_addr zone=mylimit:10m rate=10r/s;
 
-    # Logging-Einstellungen
+    # Logging-Format
     log_format main '$remote_addr - $remote_user [$time_local] "$request" '
                     '$status $body_bytes_sent "$http_referer" '
-                    '"$http_user_agent" "$http_x_forwarded_for"';
+                    '"$http_user_agent" "$http_x_forwarded_for" '
+                    'rt=$request_time uct="$upstream_connect_time" '
+                    'uht="$upstream_header_time" urt="$upstream_response_time"';
 
-    access_log /var/log/nginx/access.log main;
-    error_log /var/log/nginx/error.log warn;
+    # Container-optimierte Logs
+    access_log /dev/stdout main;
+    error_log /dev/stderr warn;
 
+    # Performance-Optimierungen
     sendfile on;
     tcp_nopush on;
     tcp_nodelay on;
     keepalive_timeout 65;
     types_hash_max_size 2048;
+    client_max_body_size 64M;
 
-    # TLS-Einstellungen
-    ssl_session_cache shared:SSL:10m;
-    ssl_session_timeout 10m;
+    # Gzip-Kompression
+    gzip on;
+    gzip_vary on;
+    gzip_min_length 1024;
+    gzip_proxied any;
+    gzip_comp_level 6;
+    gzip_types
+        text/plain
+        text/css
+        text/xml
+        text/javascript
+        application/json
+        application/javascript
+        application/xml+rss
+        application/atom+xml
+        image/svg+xml
+        application/rss+xml
+        application/vnd.ms-fontobject
+        application/x-font-ttf
+        font/opentype;
 
-    # Include server configs
+    # Basis-Sicherheits-Header
+    add_header X-Frame-Options "SAMEORIGIN" always;
+    add_header X-XSS-Protection "1; mode=block" always;
+    add_header X-Content-Type-Options "nosniff" always;
+    add_header Referrer-Policy "no-referrer-when-downgrade" always;
+
+    # SSL-Session-Cache
+    # ssl_session_cache shared:SSL:10m;
+    # ssl_session_timeout 10m;
+    # ssl_session_tickets off;
+
+    # Server-Konfigurationen einbinden
     include /etc/nginx/conf.d/*.conf;
 }
diff --git a/docker/nginx/vite-proxy.inc.dev b/docker/nginx/vite-proxy.inc.dev
new file mode 100644
index 00000000..991db4b7
--- /dev/null
+++ b/docker/nginx/vite-proxy.inc.dev
@@ -0,0 +1,4 @@
+location / {
+    try_files $uri $uri/ /index.php?$query_string;
+    autoindex off;
+}
diff --git a/docker/nginx/vite-proxy.inc.prod b/docker/nginx/vite-proxy.inc.prod
new file mode 100644
index 00000000..991db4b7
--- /dev/null
+++ b/docker/nginx/vite-proxy.inc.prod
@@ -0,0 +1,4 @@
+location / {
+    try_files $uri $uri/ /index.php?$query_string;
+    autoindex off;
+}
diff --git a/docker/php/Dockerfile b/docker/php/Dockerfile
index 18949481..d5a5c343 100644
--- a/docker/php/Dockerfile
+++ b/docker/php/Dockerfile
@@ -7,10 +7,34 @@ RUN apt-get update && apt-get install -y \
     unzip \
     libzip-dev \
     zip \
-    && docker-php-ext-install zip pdo pdo_mysql \
-    && docker-php-ext-install opcache \
+    libpng-dev \
+    libjpeg-dev \
+    libfreetype6-dev \
+    libwebp-dev \
+    libavif-dev \
+    libxpm-dev \
     && apt-get clean \
-    && rm -rf /var/lib/apt/lists/*
+        && rm -rf /var/lib/apt/lists/*
+
+RUN docker-php-ext-configure gd \
+            --with-freetype \
+            --with-jpeg \
+            --with-webp \
+            --with-avif \
+            --with-xpm \
+    && docker-php-ext-install -j$(nproc) gd
+
+RUN docker-php-ext-install -j$(nproc) \
+    zip \
+    pdo \
+    pdo_mysql \
+    opcache \
+    pcntl \
+    posix \
+    shmop
+
+RUN pecl install apcu \
+    && docker-php-ext-enable apcu
 
 # Composer installieren
 RUN curl -sS https://getcomposer.org/installer | php \
@@ -25,14 +49,21 @@ RUN if [ "$ENV" = "dev" ]; then \
 
 WORKDIR /var/www/html
 
-# Kopiere zuerst nur composer.json/lock für besseres Layer-Caching
-COPY composer.json composer.lock ./
+# Kopiere composer.json
+COPY composer.json ./
 
-# Installiere Abhängigkeiten - variiert je nach Umgebung
-RUN if [ "$ENV" = "prod" ]; then \
-    composer install --no-dev --no-scripts --no-autoloader --optimize-autoloader; \
+# Kopiere composer.lock falls vorhanden (robuste Lösung)
+COPY composer.loc[k] ./
+
+# Falls keine composer.lock existiert, erstelle eine leere um Layer-Caching zu ermöglichen
+RUN [ ! -f composer.lock ] && touch composer.lock || true
+
+# Remove potentially corrupted composer.lock and install dependencies
+RUN rm -f composer.lock && \
+    if [ "$ENV" = "prod" ]; then \
+        composer install --no-dev --no-scripts --no-autoloader --optimize-autoloader; \
     else \
-    composer install --no-scripts --no-autoloader; \
+        composer install --no-scripts --no-autoloader; \
     fi
 
 # Kopiere PHP-Konfigurationen
diff --git a/docker/php/php.common.ini b/docker/php/php.common.ini
index 1198d636..55565d63 100644
--- a/docker/php/php.common.ini
+++ b/docker/php/php.common.ini
@@ -6,3 +6,5 @@ session.cookie_samesite = Lax
 
 
 date.timezone = Europe/Berlin
+
+opcache.preload=/var/www/michaelschiemer/src/preload.php
diff --git a/docker/php/php.development.ini b/docker/php/php.development.ini
index 921652d4..e8831c9f 100644
--- a/docker/php/php.development.ini
+++ b/docker/php/php.development.ini
@@ -4,7 +4,7 @@ include = php.common.ini
 
 [opcache]
 opcache.enable=1
-opcache.enable_cli=0
+opcache.enable_cli=1
 opcache.memory_consumption=128
 opcache.max_accelerated_files=10000
 ; Häufigere Validierung im Dev-Modus
diff --git a/docker/worker/Dockerfile b/docker/worker/Dockerfile
new file mode 100644
index 00000000..aedf6c5b
--- /dev/null
+++ b/docker/worker/Dockerfile
@@ -0,0 +1,115 @@
+FROM php:8.4.8-cli
+
+# Install system dependencies including libraries for GD and other extensions
+RUN apt-get update && apt-get install -y \
+    git \
+    curl \
+    libpng-dev \
+    libjpeg62-turbo-dev \
+    libfreetype6-dev \
+    libonig-dev \
+    libxml2-dev \
+    libzip-dev \
+    libicu-dev \
+    zip \
+    unzip \
+    procps \
+    && rm -rf /var/lib/apt/lists/* \
+    && apt-get clean
+
+# Configure GD extension with JPEG and FreeType support
+RUN docker-php-ext-configure gd --with-freetype --with-jpeg
+
+# Install PHP extensions for worker functionality and web features
+RUN docker-php-ext-install -j$(nproc) \
+    pdo_mysql \
+    mbstring \
+    exif \
+    pcntl \
+    posix \
+    sockets \
+    gd \
+    zip \
+    intl \
+    opcache
+
+# Install Composer
+COPY --from=composer:latest /usr/bin/composer /usr/bin/composer
+
+# Set working directory
+WORKDIR /var/www/html
+
+# Copy application files
+COPY . .
+
+# Install dependencies (composer.lock wird automatisch erstellt falls nicht vorhanden)
+# Check if composer.json exists, if not create a minimal one
+RUN if [ ! -f composer.json ]; then \
+        echo "Creating minimal composer.json..."; \
+        echo '{\
+    "name": "worker/app",\
+    "description": "Worker application",\
+    "type": "project",\
+    "require": {\
+        "php": ">=8.4"\
+    },\
+    "autoload": {\
+        "psr-4": {\
+            "App\\\\": "src/"\
+        }\
+    },\
+    "minimum-stability": "stable",\
+    "prefer-stable": true\
+}' > composer.json; \
+    fi && \
+    composer install \
+        --no-dev \
+        --optimize-autoloader \
+        --no-interaction || echo "Composer install skipped or failed - continuing without dependencies"
+
+# Create startup script for permission fixing
+RUN echo '#!/bin/bash\n\
+set -e\n\
+\n\
+echo "🔧 Fixing permissions..."\n\
+\n\
+# Create directories if they do not exist\n\
+mkdir -p /var/www/html/src/Framework/CommandBus/storage/queue\n\
+mkdir -p /var/www/html/storage/logs\n\
+mkdir -p /var/www/html/storage/cache\n\
+\n\
+# Fix permissions on mounted volumes\n\
+chown -R www-data:www-data /var/www/html/storage || true\n\
+chown -R www-data:www-data /var/www/html/src/Framework/CommandBus/storage || true\n\
+chmod -R 775 /var/www/html/storage || true\n\
+chmod -R 775 /var/www/html/src/Framework/CommandBus/storage || true\n\
+\n\
+echo "✅ Permissions fixed"\n\
+echo "🚀 Starting worker..."\n\
+\n\
+# Switch to www-data user and run the worker\n\
+exec gosu www-data php /var/www/html/worker.php\n' > /usr/local/bin/start-worker.sh \
+    && chmod +x /usr/local/bin/start-worker.sh
+
+# Install gosu for better user switching (alternative to su-exec for Debian)
+RUN apt-get update && apt-get install -y gosu && rm -rf /var/lib/apt/lists/*
+
+# Create necessary directories and set permissions
+RUN mkdir -p \
+    /var/www/html/src/Framework/CommandBus/storage/queue \
+    /var/www/html/storage/logs \
+    /var/www/html/storage/cache \
+    && chown -R www-data:www-data /var/www/html/storage \
+    && chmod -R 775 /var/www/html/storage
+
+# Create queue storage directory with proper permissions
+RUN mkdir -p /var/www/html/src/Framework/CommandBus/storage \
+    && chown -R www-data:www-data /var/www/html/src/Framework/CommandBus/storage \
+    && chmod -R 775 /var/www/html/src/Framework/CommandBus/storage
+
+# Health check for the worker
+HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 \
+    CMD ps aux | grep -v grep | grep "worker.php" || exit 1
+
+# Use startup script instead of direct PHP command
+CMD ["/usr/local/bin/start-worker.sh"]
diff --git a/docs/MARKDOWN.md b/docs/MARKDOWN.md
new file mode 100644
index 00000000..cc718c24
--- /dev/null
+++ b/docs/MARKDOWN.md
@@ -0,0 +1,61 @@
+# Heading 1
+## Heading 2
+### Heading 3
+#### Heading 4
+##### Heading 5
+###### Heading 6
+
+*italics*
+
+**bold**
+
+***italics & bold***
+
+~~crossed off~~
+
+<mark>highlight</mark>
+
+<sub>Test</sub>
+
+`monospace`
+
+```html
+
+<html>
+    <header></header>
+
+    <footer></footer>
+</html>
+
+
+
+```
+
+[This is a link](https://localhost)
+
+![Image](url)
+
+> This is a blockquote
+>> and it can be nested
+
+***
+
+---
+
+___
+
+1. Item 1
+2. Item 2
+3. Item 3
+
+* Test
+* Test
+    * Subitem
+    * Subitem
+
+| Column1 | Column 2 |
+| --- |-----|
+| Test | Test2 |
+
+- [ ] Test
+- [x] Test 2
diff --git a/docs/README.md b/docs/README.md
new file mode 100644
index 00000000..cc6159b0
--- /dev/null
+++ b/docs/README.md
@@ -0,0 +1,77 @@
+# Projekt-Dokumentation
+
+## Übersicht
+
+Willkommen zur Dokumentation des Projekts. Diese Dokumentation dient als zentrale Informationsquelle für Entwickler, die am Projekt arbeiten.
+
+## Inhaltsverzeichnis
+
+### Standards und Guidelines
+
+- [Coding Guidelines](/docs/standards/CODING-GUIDELINES.md) - Allgemeine Coding-Standards für das Projekt
+- [Sicherheitsrichtlinien](/docs/standards/SICHERHEITS-GUIDELINES.md) - Standards für sichere Softwareentwicklung
+
+### Entwicklungsrichtlinien
+
+- [Performance Guidelines](/docs/guidelines/PERFORMANCE-GUIDELINES.md) - Richtlinien zur Optimierung der Anwendungsleistung
+- [Testing Guidelines](/docs/guidelines/TESTING-GUIDELINES.md) - Standards und Best Practices für Tests
+
+### KI-Assistent Konfiguration
+
+- [Guidelines für KI-Assistenten](/docs/ai/GUIDELINES-FÜR-AI-ASSISTANT.md) - Spezifische Richtlinien für den KI-Assistenten
+- [PhpStorm Einrichtung](/docs/ai/EINRICHTUNG-PHPSTORM.md) - Anleitung zur Einrichtung des KI-Assistenten in PhpStorm
+
+### Architektur und Struktur
+
+- [Projektstruktur](/docs/architecture/STRUKTUR-DOKUMENTATION.md) - Überblick über die Struktur des Projekts
+
+### Framework-Entwicklung
+
+- [Modul-Checkliste](/docs/framework/MODUL-CHECKLISTE.md) - Leitfaden für die Erstellung neuer Module
+- [Erweiterungsmuster](/docs/framework/ERWEITERUNGSPATTERN.md) - Muster zur Erweiterung des Frameworks
+
+### Framework-Module
+
+- [Analytics-Modul](/docs/framework/analytics/README.md) - Tracking und Analyse von Anwendungsdaten
+- [Core-Modul](/docs/framework/core/README.md) - Kernkomponenten und Event-System
+- [DI-Modul](/docs/framework/di/README.md) - Dependency-Injection-Container
+- [HTTP-Modul](/docs/framework/http/README.md) - HTTP-Request und -Response-Handling
+
+## Mitwirken
+
+### Neue Module entwickeln
+
+1. Folge der [Framework-Modul Checkliste](/docs/framework/MODUL-CHECKLISTE.md) für neue Module
+2. Stelle sicher, dass dein Code den [Coding Guidelines](/docs/standards/CODING-GUIDELINES.md) entspricht
+3. Schreibe Tests gemäß den [Testing Guidelines](/docs/guidelines/TESTING-GUIDELINES.md)
+4. Erstelle eine ausführliche Dokumentation für dein Modul
+
+### Dokumentation verbessern
+
+Wir begrüßen Beiträge zur Verbesserung der Dokumentation. Wenn du Fehler findest oder Vorschläge zur Verbesserung hast, erstelle bitte einen Pull Request mit deinen Änderungen.
+
+## Erste Schritte
+
+Neue Entwickler sollten mit folgenden Schritten beginnen:
+
+1. Projekt lokal einrichten (siehe [Installation](#installation))
+2. Die [Projektstruktur](/docs/architecture/STRUKTUR-DOKUMENTATION.md) verstehen
+3. Die [Coding Guidelines](/docs/standards/CODING-GUIDELINES.md) lesen
+4. PhpStorm mit dem [KI-Assistenten einrichten](/docs/ai/EINRICHTUNG-PHPSTORM.md)
+
+## Installation
+
+```bash
+# Repository klonen
+git clone [repository-url]
+
+# Abhängigkeiten installieren
+composer install
+
+# Entwicklungsserver starten
+php -S localhost:8000 -t public/
+```
+
+## Updates und Änderungen
+
+Diese Dokumentation wird kontinuierlich aktualisiert. Prüfe regelmäßig auf Aktualisierungen, um über die neuesten Best Practices und Standards informiert zu bleiben.
diff --git a/docs/WORKER.md b/docs/WORKER.md
new file mode 100644
index 00000000..ba08b44a
--- /dev/null
+++ b/docs/WORKER.md
@@ -0,0 +1,16 @@
+# Queue Worker - Docker Management
+
+Dieses Dokument beschreibt alle Docker-spezifischen Befehle für die Verwaltung des Queue Workers.
+
+## 📋 Inhaltsverzeichnis
+
+- [Schnellstart](#schnellstart)
+- [Worker Management](#worker-management)
+- [Monitoring & Debugging](#monitoring--debugging)
+- [Konfiguration](#konfiguration)
+- [Troubleshooting](#troubleshooting)
+- [Wartung](#wartung)
+
+## 🚀 Schnellstart
+
+### Worker starten
diff --git a/docs/ai/EINRICHTUNG-PHPSTORM.md b/docs/ai/EINRICHTUNG-PHPSTORM.md
new file mode 100644
index 00000000..93ff5832
--- /dev/null
+++ b/docs/ai/EINRICHTUNG-PHPSTORM.md
@@ -0,0 +1,53 @@
+# Einrichtung des KI-Assistenten in PhpStorm
+
+## Übersicht
+
+Diese Anleitung beschreibt, wie der KI-Assistent in PhpStorm eingerichtet wird, um automatisch die Projekt-Guidelines zu verwenden.
+
+## Methode 1: Über die PhpStorm-Einstellungen
+
+1. Öffne PhpStorm und gehe zu **Settings/Preferences**
+   - Windows/Linux: File → Settings
+   - macOS: PhpStorm → Preferences
+
+2. Navigiere zu **Tools** → **AI Assistant** → **Custom Instructions**
+
+3. Aktiviere die Option **Use custom instructions**
+
+4. Füge in das Textfeld den Inhalt aus der Datei `/docs/ai/GUIDELINES-FÜR-AI-ASSISTANT.md` ein
+   - Alternativ kannst du auf einen relativen Pfad verweisen
+
+5. Aktiviere die Option **Apply project-specific instructions**, damit diese Einstellungen nur für dieses Projekt gelten
+
+6. Klicke auf **Apply** und dann auf **OK**
+
+## Methode 2: Über die Projektkonfiguration (empfohlen)
+
+Die `.idea/aiAssistant.xml`-Datei ist bereits im Projekt enthalten und konfiguriert den KI-Assistenten automatisch mit den richtigen Einstellungen. Wenn du das Projekt öffnest, sollte der KI-Assistent bereits korrekt eingerichtet sein.
+
+Um zu überprüfen, ob die Einstellungen korrekt übernommen wurden:
+
+1. Öffne die PhpStorm-Einstellungen wie oben beschrieben
+2. Navigiere zu **Tools** → **AI Assistant** → **Custom Instructions**
+3. Überprüfe, ob **Use custom instructions** aktiviert ist und die Guidelines angezeigt werden
+
+## Testen der Einrichtung
+
+Um zu testen, ob der KI-Assistent die Guidelines korrekt anwendet:
+
+1. Öffne eine PHP-Datei im Projekt
+2. Drücke `Alt+A` (Windows/Linux) oder `Option+A` (macOS) um den KI-Assistenten zu öffnen
+3. Bitte den Assistenten, eine neue Klasse zu erstellen
+4. Überprüfe, ob die generierte Klasse den Guidelines entspricht:
+   - Sie sollte als `final` und wenn möglich `readonly` deklariert sein
+   - Constructor Property Promotion sollte verwendet werden
+   - Es sollten keine externen Abhängigkeiten importiert werden
+
+## Fehlerbehebung
+
+Falls die Guidelines nicht korrekt angewendet werden:
+
+1. Stelle sicher, dass du die neueste Version von PhpStorm verwendest
+2. Überprüfe, ob die AI Assistant-Funktion aktiviert ist
+3. Versuche, das Projekt neu zu öffnen
+4. Führe einen Cache-Clear in PhpStorm durch: File → Invalidate Caches
diff --git a/docs/ai/GUIDELINES-FÜR-AI-ASSISTANT.md b/docs/ai/GUIDELINES-FÜR-AI-ASSISTANT.md
new file mode 100644
index 00000000..41f8c10a
--- /dev/null
+++ b/docs/ai/GUIDELINES-FÜR-AI-ASSISTANT.md
@@ -0,0 +1,174 @@
+# Guidelines für KI-Assistenten
+
+## Übersicht
+
+Diese Guidelines helfen dir, dem KI-Assistenten, konsistenten, modernen und qualitativ hochwertigen PHP-Code zu generieren, der den Projektstandards entspricht.
+
+## Verwendung in PhpStorm
+
+Diese Guidelines können in PhpStorm so eingerichtet werden, dass sie automatisch vom KI-Assistenten verwendet werden:
+
+1. Gehe zu **Settings/Preferences** → **Tools** → **AI Assistant** → **Custom Instructions**
+2. Aktiviere **Use custom instructions**
+3. Füge im Textfeld den Inhalt dieser Datei ein oder verwende einen relativen Pfad zu dieser Datei
+4. Optional: Aktiviere **Apply project-specific instructions** für projektspezifische Einstellungen
+
+Alternativ kann die Datei `.idea/aiAssistant.xml` angepasst werden, um diese Guidelines als Standardeinstellung für das Projekt zu verwenden.
+
+## Kernprinzipien
+
+### Abhängigkeitsvermeidung
+
+- **Keine externen Abhängigkeiten** außer den explizit freigegebenen
+- Eigene Implementierungen gegenüber externen Bibliotheken bevorzugen
+- Bei Bedarf nach externen Funktionen zuerst prüfen, ob eine eigene Implementierung möglich ist
+- Erlaubte Abhängigkeiten sind auf die vorhandenen Composer-Pakete beschränkt
+
+## Architekturprinzipien
+
+Bei der Codeanalyse und -generierung sind folgende Architekturprinzipien zu beachten:
+
+1. **Modularer Aufbau**: Das Projekt ist in Module unter `/src/Framework/` organisiert
+2. **Service-orientierte Architektur**: Funktionalitäten als unabhängige Services implementieren
+3. **Dependency Injection**: Abhängigkeiten werden per Constructor Injection bereitgestellt
+4. **Event-basierte Kommunikation**: Module kommunizieren über den EventDispatcher
+5. **Selbstständigkeit**: Module sollten möglichst unabhängig von externen Bibliotheken sein
+
+## Coding-Standards
+
+### Klassen
+
+- **IMMER `final` verwenden**, außer bei zwingenden Gründen für Vererbung
+- **KEINE abstrakten Klassen** verwenden - stattdessen Interfaces und Kompositionen
+- Klassen und Properties wenn möglich als `readonly` deklarieren
+- Bevorzuge Interfaces für Vertragsgestaltung zwischen Komponenten
+
+```php
+// RICHTIG
+final readonly class AnalyticsService implements AnalyticsInterface
+{
+    // ...
+}
+
+// FALSCH
+abstract class BaseAnalytics
+{
+    // ...
+}
+```
+
+### Properties und Methoden
+
+- Private `readonly` Properties mit Typisierung
+- Return-Types immer angeben
+- Parameter-Types immer angeben
+- Union Types und Nullable Types nutzen
+
+```php
+// RICHTIG
+private readonly LoggerInterface $logger;
+
+public function process(?int $id): Result|null
+{
+    // ...
+}
+
+// FALSCH
+public $logger;
+
+public function process($id)
+{
+    // ...
+}
+```
+
+### Moderne PHP-Features
+
+Nutze aktiv die neuesten PHP-Features:
+
+- Constructor Property Promotion
+- Match Expressions statt Switch
+- Named Arguments
+- Enums statt Konstanten
+- Nullsafe Operator (`?->`) wo sinnvoll
+- Typed Properties
+
+## Klassenaufbau
+
+Folgende Reihenfolge für Klassenelemente:
+
+1. Konstanten
+2. Properties
+3. Constructor
+4. Öffentliche Methoden
+5. Private/Protected Methoden
+
+## Service-Initialisierung
+
+Services werden durch Initializer-Klassen registriert:
+
+```php
+#[Initializer]
+final readonly class ServiceInitializer
+{
+    public function __construct(
+        private Configuration $config,
+        private DependencyInterface $dependency
+    ) {}
+
+    public function __invoke(Container $container): ServiceInterface
+    {
+        return new Service(
+            $this->config->get('service'),
+            $this->dependency
+        );
+    }
+}
+```
+
+## Fehlerbehandlung
+
+- Spezifische Exception-Klassen werfen
+- Early Return Pattern bevorzugen
+- Defensive Programmierung mit Validierung
+
+## Testing
+
+Bei Test-Vorschlägen Pest-Framework nutzen:
+
+```php
+test('method does something correctly', function () {
+    // Arrangement
+    $service = new Service($dependency);
+
+    // Action
+    $result = $service->method();
+
+    // Assertion
+    expect($result)->toBe('expected');
+});
+```
+
+## Dokumentation
+
+- PHPDoc für alle öffentlichen Methoden
+- Kurze, präzise Beschreibungen
+- Parameter und Return-Types in PHPDoc
+
+## Zu vermeidende Praktiken
+
+- Globale Zustände und statische Methoden
+- Tiefe Vererbungshierarchien
+- Lange, komplexe Methoden
+- Magische Methoden (`__call`, etc.) ohne triftigen Grund
+- Unnötige Abstraktionen
+
+## Bei Codeanalyse und -vorschlägen
+
+1. **Aktuellen Stil beibehalten**: Bei Vorschlägen den vorhandenen Codierungsstil beibehalten
+2. **Standards berücksichtigen**: Auf Einhaltung der hier definierten Guidelines achten
+3. **Modernisierung vorschlagen**: Auf Möglichkeiten zur Modernisierung hinweisen
+4. **Begründen**: Bei Empfehlungen die Gründe erläutern
+5. **Vollständigkeit**: Vollständige Lösungen anbieten, nicht nur Fragmente
+
+Diese Guidelines sind als lebendiges Dokument zu betrachten, das mit der Evolution des Projekts und von PHP weiterentwickelt wird.
diff --git a/docs/ai/index.md b/docs/ai/index.md
new file mode 100644
index 00000000..6b962f71
--- /dev/null
+++ b/docs/ai/index.md
@@ -0,0 +1,54 @@
+# KI-Assistent Dokumentation
+
+## Übersicht
+
+Diese Dokumentation beschreibt die Einrichtung und Verwendung des KI-Assistenten im Projekt. Der KI-Assistent hilft bei der Entwicklung durch Code-Generierung, Refactoring-Vorschläge und mehr, während er die Projektstandards einhält.
+
+## Inhalte
+
+- [Guidelines für KI-Assistenten](/ai/GUIDELINES-FÜR-AI-ASSISTANT.md) - Richtlinien für den KI-Assistenten
+- [PhpStorm Einrichtung](/ai/EINRICHTUNG-PHPSTORM.md) - Anleitung zur Einrichtung in PhpStorm
+
+## KI-Assistent Guidelines
+
+Die [Guidelines für KI-Assistenten](/ai/GUIDELINES-FÜR-AI-ASSISTANT.md) stellen sicher, dass der KI-generierte Code den Projektstandards entspricht:
+
+- Einhaltung der Coding-Standards
+- Vermeidung externer Abhängigkeiten
+- Verwendung moderner PHP-Features
+- Konsistente Klassenstruktur
+- Korrekte Fehlerbehandlung
+
+## Einrichtung in PhpStorm
+
+Die [PhpStorm Einrichtungsanleitung](/ai/EINRICHTUNG-PHPSTORM.md) führt Sie durch den Prozess der Integration des KI-Assistenten in Ihre IDE:
+
+- Konfiguration der Custom Instructions
+- Verwendung der projektspezifischen Einstellungen
+- Testen der korrekten Einrichtung
+- Fehlerbehebung bei Problemen
+
+## Effektive Nutzung des KI-Assistenten
+
+### Best Practices
+
+1. **Klare Anfragen stellen**: Je präziser die Anfrage, desto besser das Ergebnis
+2. **Kontext bereitstellen**: Dem Assistenten relevanten Kontext geben
+3. **Ergebnisse überprüfen**: Generierte Code immer prüfen und verstehen
+4. **Iterativ arbeiten**: Bei komplexen Aufgaben schrittweise vorgehen
+
+### Häufige Anwendungsfälle
+
+- Erstellung neuer Klassen und Interfaces
+- Implementierung von Tests
+- Refactoring bestehenden Codes
+- Dokumentation generieren
+- Code-Optimierung
+
+## Datenschutz und Sicherheit
+
+Beim Umgang mit dem KI-Assistenten sollten Sie folgende Punkte beachten:
+
+- Keine sensiblen Daten oder Geschäftsgeheimnisse teilen
+- Keine Passwörter, API-Schlüssel oder Zugangsdaten teilen
+- Bei Unsicherheit den KI-Assistenten nicht verwenden
diff --git a/docs/architecture/STRUKTUR-DOKUMENTATION.md b/docs/architecture/STRUKTUR-DOKUMENTATION.md
new file mode 100644
index 00000000..68f2361f
--- /dev/null
+++ b/docs/architecture/STRUKTUR-DOKUMENTATION.md
@@ -0,0 +1,149 @@
+# Projektstruktur-Dokumentation
+
+## Übersicht
+
+Diese Dokumentation bietet einen Überblick über die Architektur und Struktur des Projekts. Die Anwendung folgt einer modularen, serviceorientierten Architektur mit klarer Trennung von Verantwortlichkeiten.
+
+## Hauptverzeichnisse
+
+### `/src`
+
+Das Hauptverzeichnis für den Anwendungscode, unterteilt in mehrere Unterverzeichnisse:
+
+#### `/src/Framework`
+
+Enthält das Framework mit grundlegenden Infrastrukturkomponenten:
+
+- **Analytics**: System zur Erfassung und Analyse von Anwendungsdaten
+- **Attributes**: Attribute/Annotations für Metadaten
+- **Cache**: Caching-Mechanismen
+- **CommandBus**: Command-Handling-Komponenten
+- **Config**: Konfigurationsverwaltung
+- **Console**: Konsolenanwendung und -befehle
+- **Core**: Kernkomponenten und Events
+- **DI**: Dependency-Injection-Container
+- **ErrorHandling**: Fehlerbehandlungsmechanismen
+- **EventBus**: Event-Handling-System
+- **Exception**: Framework-Exceptions
+- **Filesystem**: Dateisystemoperationen
+- **Http**: HTTP-Request/Response-Handling
+- **HttpClient**: HTTP-Client für externe API-Aufrufe
+- **Logging**: Logging-Infrastruktur
+- **Performance**: Performance-Monitoring
+- **Queue**: Nachrichtenwarteschlangen
+- **Redis**: Redis-Integration
+- **Router**: URL-Routing
+- **StaticSite**: Statische Site-Generation
+- **Validation**: Datenvalidierung
+- **View**: Template-Rendering
+
+#### `/src/Application`
+
+Anwendungsspezifische Komponenten, die das Framework nutzen.
+
+#### `/src/Domain`
+
+Domain-Modelle, Entities und Business-Logik.
+
+#### `/src/Infrastructure`
+
+Infrastrukturkomponenten, die externe Systeme integrieren.
+
+#### `/src/Config`
+
+Konfigurationsdateien für verschiedene Module.
+
+## Framework-Architektur
+
+### Dependency Injection
+
+Das System nutzt einen leistungsfähigen DI-Container zur Verwaltung von Services:
+
+```php
+#[Initializer]
+class ServiceInitializer
+{
+    public function __invoke(Container $container): Service
+    {
+        // Service erstellen und zurückgeben
+    }
+}
+```
+
+### Event-System
+
+Ein Event-System ermöglicht lose Kopplung zwischen Komponenten:
+
+```php
+$eventDispatcher->addHandler(EventClass::class, function($event) {
+    // Event verarbeiten
+});
+```
+
+### HTTP-Pipeline
+
+HTTP-Requests durchlaufen eine Middleware-Pipeline:
+
+```php
+class CustomMiddleware implements Middleware
+{
+    public function process(Request $request, callable $next): Response
+    {
+        // Request verarbeiten
+        $response = $next($request);
+        // Response verarbeiten
+        return $response;
+    }
+}
+```
+
+## Module und ihre Interaktionen
+
+### Analytics-Modul
+
+Das Analytics-Modul erfasst und analysiert Anwendungsdaten:
+
+- **Events tracken**: `$analytics->track('event_name', $properties)`
+- **HTTP-Tracking**: Automatisch durch `AnalyticsMiddleware`
+- **Error-Tracking**: Integration mit dem Error-Handling-System
+- **Dashboard**: Admin-Interface zur Datenvisualisierung
+
+### Konfigurationssystem
+
+Konfigurationen werden zentral verwaltet und injiziert:
+
+```php
+class Service
+{
+    public function __construct(private Configuration $config)
+    {
+        $settings = $this->config->get('module_name', $defaults);
+    }
+}
+```
+
+## Erweiterbarkeit
+
+### Neue Module hinzufügen
+
+1. Erstellen Sie ein neues Verzeichnis unter `/src/Framework`
+2. Implementieren Sie eine Initializer-Klasse mit dem `#[Initializer]`-Attribut
+3. Erstellen Sie eine entsprechende Konfigurationsdatei unter `/src/Config`
+
+### Middleware hinzufügen
+
+```php
+// In Ihrer Anwendungsklasse
+public function bootstrap(): void
+{
+    $this->addMiddleware(YourMiddleware::class);
+}
+```
+
+## Best Practices
+
+- **Dependency Injection**: Verwenden Sie Constructor-Injection für Abhängigkeiten
+- **Interfaces**: Definieren Sie Interfaces für alle Services
+- **Events**: Nutzen Sie Events für lose Kopplung zwischen Modulen
+- **Konfiguration**: Externalisieren Sie Konfigurationen in dedizierte Dateien
+- **Typsicherheit**: Nutzen Sie strenge Typisierung und readonly-Properties
diff --git a/docs/architecture/index.md b/docs/architecture/index.md
new file mode 100644
index 00000000..5723f40c
--- /dev/null
+++ b/docs/architecture/index.md
@@ -0,0 +1,70 @@
+# Architektur-Dokumentation
+
+## Übersicht
+
+Diese Dokumentation beschreibt die Architektur und Struktur des Projekts. Sie bietet einen Überblick über die wichtigsten Komponenten, deren Beziehungen und die zugrundeliegenden Architekturprinzipien.
+
+## Inhalte
+
+- [Projektstruktur](/architecture/STRUKTUR-DOKUMENTATION.md) - Überblick über die Struktur des Projekts
+
+## Architekturprinzipien
+
+Das Projekt folgt diesen grundlegenden Architekturprinzipien:
+
+1. **Modulare Architektur**: Klare Trennung von Verantwortlichkeiten in Modulen
+2. **Service-orientiertes Design**: Funktionalitäten als unabhängige Services
+3. **Dependency Injection**: Abhängigkeiten werden explizit injiziert
+4. **Event-basierte Kommunikation**: Lose Kopplung durch Events
+5. **Schichtenarchitektur**: Trennung von Präsentation, Anwendungslogik und Daten
+
+## Hauptkomponenten
+
+### Framework-Kern
+
+Der Framework-Kern stellt grundlegende Infrastrukturkomponenten bereit:
+
+- **DI-Container**: Verwaltung von Service-Abhängigkeiten
+- **Event-System**: Event-basierte Kommunikation
+- **HTTP-Komponenten**: Request/Response-Handling
+- **Routing**: URL-zu-Controller-Mapping
+
+### Anwendungsschicht
+
+Die Anwendungsschicht implementiert die Geschäftslogik:
+
+- **Services**: Implementierung von Anwendungsfunktionen
+- **Commands/Queries**: Command-Query-Separation-Prinzip
+- **Controllers**: HTTP-Request-Handling
+
+### Domainschicht
+
+Die Domainschicht enthält die Kerngeschäftslogik:
+
+- **Entities**: Geschäftsobjekte mit Identität
+- **Value Objects**: Unveränderliche Wertobjekte
+- **Domain Services**: Domänenspezifische Logik
+
+### Infrastrukturschicht
+
+Die Infrastrukturschicht bietet technische Funktionen:
+
+- **Persistenz**: Datenbankzugriff und -verwaltung
+- **Messaging**: Externe Kommunikation
+- **Integration**: Anbindung an externe Systeme
+
+## Datenfluss
+
+Ein typischer Datenfluss im System:
+
+1. HTTP-Request wird vom Router empfangen
+2. Middleware-Pipeline verarbeitet den Request
+3. Controller erhält den Request und delegiert an Services
+4. Services implementieren die Geschäftslogik
+5. Domain-Objekte repräsentieren den Geschäftszustand
+6. Repositories speichern/laden Daten
+7. Response wird erstellt und zurückgegeben
+
+## Weitere Informationen
+
+Für detailliertere Informationen zur Architektur siehe die [Projektstruktur-Dokumentation](/architecture/STRUKTUR-DOKUMENTATION.md).
diff --git a/docs/framework/ANALYTICS.md b/docs/framework/ANALYTICS.md
new file mode 100644
index 00000000..5f61a82e
--- /dev/null
+++ b/docs/framework/ANALYTICS.md
@@ -0,0 +1,14 @@
+# Analytics-Framework
+
+> **Dokumentationshinweis:** Die vollständige Dokumentation für das Analytics-Framework finden Sie im Ordner [/docs/framework/analytics](/docs/framework/analytics/).
+
+## Schnellzugriff
+
+- [Übersicht und Einstieg](/docs/framework/analytics/index.md)
+- [Detaillierte Architektur](/docs/framework/analytics/architecture.md)
+- [Anwendungsbeispiele](/docs/framework/analytics/usage.md)
+- [Migrationsleitfaden](/docs/framework/analytics/migration.md)
+
+## Implementierungsdetails
+
+Die Code-Dokumentation befindet sich in der [README-Datei des Frameworks](/Framework/Analytics1/README.md).
diff --git a/docs/framework/ERWEITERUNGSPATTERN.md b/docs/framework/ERWEITERUNGSPATTERN.md
new file mode 100644
index 00000000..565dd261
--- /dev/null
+++ b/docs/framework/ERWEITERUNGSPATTERN.md
@@ -0,0 +1,200 @@
+# Erweiterungsmuster im Framework
+
+## Übersicht
+
+Dieses Dokument beschreibt die verschiedenen Muster und Techniken, um das Framework zu erweitern oder anzupassen, ohne den Kern-Code zu verändern.
+
+## Event-basierte Erweiterungen
+
+### Event-Listener
+
+Die primäre Methode zur Erweiterung des Frameworks ist das Lauschen auf System-Events:
+
+```php
+// Event-Listener registrieren
+public function __construct(private readonly EventDispatcher $eventDispatcher)
+{
+    $this->eventDispatcher->addHandler(
+        'App\Framework\Core\Events\ApplicationBooted',
+        [$this, 'onApplicationBooted']
+    );
+}
+
+// Event-Handler-Methode
+public function onApplicationBooted(ApplicationBooted $event): void
+{
+    // Erweiterungslogik implementieren
+}
+```
+
+### Eigene Events
+
+Benutzerdefinierte Events erstellen:
+
+```php
+final readonly class UserRegistered
+{
+    public function __construct(
+        public string $userId,
+        public string $email,
+        public \DateTimeImmutable $timestamp
+    ) {}
+}
+
+// Event auslösen
+$this->eventDispatcher->dispatch(new UserRegistered(
+    $user->getId(),
+    $user->getEmail(),
+    new \DateTimeImmutable()
+));
+```
+
+## Middleware
+
+HTTP-Anfragen können durch Middleware-Klassen erweitert werden:
+
+```php
+final readonly class CustomMiddleware implements Middleware
+{
+    public function process(Request $request, callable $next): Response
+    {
+        // Vor der Anfrageverarbeitung
+        $modifiedRequest = $this->modifyRequest($request);
+
+        // Anfrage weiterleiten
+        $response = $next($modifiedRequest);
+
+        // Nach der Anfrageverarbeitung
+        return $this->modifyResponse($response);
+    }
+}
+
+// Middleware registrieren
+$app->addMiddleware(CustomMiddleware::class);
+```
+
+## Service-Erweiterungen
+
+### Service-Ersetzen
+
+Standardimplementierungen durch eigene ersetzen:
+
+```php
+#[Initializer]
+final readonly class CustomStorageInitializer
+{
+    public function __invoke(Container $container): StorageInterface
+    {
+        return new CustomStorage();
+    }
+}
+```
+
+### Service-Decorator
+
+Bestehende Services erweitern ohne Änderung der Original-Implementierung:
+
+```php
+#[Initializer]
+final readonly class LoggingAnalyticsInitializer
+{
+    public function __construct(
+        private readonly Configuration $config,
+        private readonly LoggerInterface $logger
+    ) {}
+
+    public function __invoke(Container $container): Analytics
+    {
+        // Original-Analytics-Service erstellen
+        $originalAnalytics = new Analytics(
+            new AnalyticsManager($this->config->get('analytics'), new FileStorage($path)),
+            $container->get(EventDispatcher::class)
+        );
+
+        // Mit Logging-Decorator umhüllen
+        return new LoggingAnalyticsDecorator($originalAnalytics, $this->logger);
+    }
+}
+
+// Decorator-Implementierung
+final readonly class LoggingAnalyticsDecorator implements AnalyticsInterface
+{
+    public function __construct(
+        private Analytics $analytics,
+        private LoggerInterface $logger
+    ) {}
+
+    public function track(string $event, array $properties = [], ?string $userId = null): void
+    {
+        $this->logger->debug("Tracking event: {$event}", [
+            'properties' => $properties,
+            'user_id' => $userId
+        ]);
+
+        $this->analytics->track($event, $properties, $userId);
+    }
+
+    // Andere Methoden implementieren
+}
+```
+
+## Plugin-System
+
+### Plugin-Interface
+
+```php
+interface PluginInterface
+{
+    public function register(Application $app): void;
+    public function boot(Application $app): void;
+}
+
+// Plugin-Implementierung
+final readonly class CustomPlugin implements PluginInterface
+{
+    public function register(Application $app): void
+    {
+        // Services registrieren
+    }
+
+    public function boot(Application $app): void
+    {
+        // Nach Initialisierung der Anwendung
+    }
+}
+
+// Plugin registrieren
+$app->registerPlugin(new CustomPlugin());
+```
+
+## Konfigurationserweiterungen
+
+### Konfigurationsquellen
+
+Benutzerdefinierte Konfigurationsquellen implementieren:
+
+```php
+final readonly class EnvironmentConfigSource implements ConfigSourceInterface
+{
+    public function load(string $key, mixed $default = null): mixed
+    {
+        $envKey = strtoupper(str_replace('.', '_', $key));
+        return $_ENV[$envKey] ?? $default;
+    }
+}
+
+// Konfigurationsquelle registrieren
+$config->addSource(new EnvironmentConfigSource());
+```
+
+## Zusammenfassung
+
+Die bevorzugten Erweiterungsmuster sind:
+
+1. **Event-Listener** für reaktive Erweiterungen
+2. **Middleware** für HTTP-Anfrageverarbeitung
+3. **Service-Initializer** zum Ersetzen oder Dekorieren von Services
+4. **Plugins** für umfassendere Funktionalitätserweiterungen
+5. **Konfigurationsquellen** für benutzerdefinierte Konfigurationen
+
+Diese Muster ermöglichen es, das Framework zu erweitern, ohne den Kern zu modifizieren, was zu einer besseren Wartbarkeit und einfacheren Updates führt.
diff --git a/docs/framework/MODUL-CHECKLISTE.md b/docs/framework/MODUL-CHECKLISTE.md
new file mode 100644
index 00000000..a074da28
--- /dev/null
+++ b/docs/framework/MODUL-CHECKLISTE.md
@@ -0,0 +1,73 @@
+# Framework-Modul Checkliste
+
+## Übersicht
+
+Diese Checkliste dient als Leitfaden für die Erstellung neuer Module im Framework. Sie hilft sicherzustellen, dass alle Module den Projektstandards entsprechen und konsistent implementiert werden.
+
+## Strukturelle Anforderungen
+
+- [ ] Modul in eigenem Verzeichnis unter `/src/Framework/`
+- [ ] Konsistente Namensgebung im PascalCase (z.B. `CacheManager` statt `Cache_manager`)
+- [ ] README.md mit Modul-Dokumentation
+- [ ] Interface(s) für öffentliche API
+- [ ] Implementierungsklassen als `final readonly`
+- [ ] Initializer-Klasse mit `#[Initializer]`-Attribut
+
+## Abhängigkeiten
+
+- [ ] Minimale externe Abhängigkeiten (idealerweise keine)
+- [ ] Klar definierte Abhängigkeiten zu anderen Framework-Modulen
+- [ ] Keine zirkulären Abhängigkeiten
+- [ ] Verwendung des DI-Containers für Abhängigkeiten
+
+## Konfiguration
+
+- [ ] Konfigurationsdatei unter `/src/Config/{modul-name}.php`
+- [ ] Standardkonfiguration in der Initializer-Klasse
+- [ ] Dokumentierte Konfigurationsoptionen
+
+## Code-Qualität
+
+- [ ] Vollständige Typisierung (Parameter, Rückgabewerte, Properties)
+- [ ] PHPDoc für öffentliche Methoden und Klassen
+- [ ] Keine abstrakten Klassen oder Vererbung (außer Interfaces)
+- [ ] Immutable Objekte wo möglich
+- [ ] Spezifische Exceptions für Fehlerbehandlung
+
+## Tests
+
+- [ ] Unit-Tests mit Pest für alle öffentlichen Methoden
+- [ ] Integrationstests für Modul-Interaktionen
+- [ ] Testabdeckung für Fehlerfälle
+
+## Integration
+
+- [ ] Event-Listener für relevante System-Events
+- [ ] Erweiterungspunkte für andere Module
+- [ ] Keine direkten Abhängigkeiten zu Domain-Klassen
+
+## Dokumentation
+
+- [ ] Beispiele für Verwendung
+- [ ] Architektur-Beschreibung
+- [ ] API-Dokumentation
+- [ ] Konfigurationsreferenz
+
+## Performance
+
+- [ ] Lazy-Loading für ressourcenintensive Operationen
+- [ ] Caching-Strategie (falls relevant)
+- [ ] Performancekritische Teile identifiziert und optimiert
+
+## Sicherheit
+
+- [ ] Validierung aller externen Eingaben
+- [ ] Keine sensiblen Daten in Logs
+- [ ] Schutz vor bekannten Sicherheitslücken
+
+## Wartbarkeit
+
+- [ ] Kleine, fokussierte Klassen
+- [ ] Klare Trennung von Verantwortlichkeiten
+- [ ] Konsistente Fehlerbehandlung
+- [ ] Logging an strategischen Stellen
diff --git a/docs/framework/analytics/README.md b/docs/framework/analytics/README.md
new file mode 100644
index 00000000..b4a7e85a
--- /dev/null
+++ b/docs/framework/analytics/README.md
@@ -0,0 +1,158 @@
+# Analytics-Modul Dokumentation
+
+## Übersicht
+
+Das Analytics-Modul ist ein internes Tracking- und Analysesystem, das ohne externe Abhängigkeiten Benutzeraktivitäten, Systemereignisse und Leistungsdaten erfasst und analysiert.
+
+## Kernkomponenten
+
+### Analytics (Analytics.php)
+
+Die Hauptklasse, die als zentraler Einstiegspunkt für das Tracking von Events dient.
+
+**Hauptfunktionen:**
+- `track()`: Zeichnet ein generisches Event auf
+- `page()`: Spezifisch für Seitenaufrufe
+- `user()`: Verfolgt Benutzeridentifikation
+- `performance()`: Erfasst Leistungsmetriken
+- `error()`: Protokolliert Fehler und Ausnahmen
+
+### AnalyticsManager (AnalyticsManager.php)
+
+Verwaltet die Verarbeitung und Speicherung von Events.
+
+**Hauptfunktionen:**
+- `track()`: Verarbeitet Events und wendet Middleware an
+- `addMiddleware()`: Fügt Verarbeitungsfunktionen hinzu
+- `flush()`: Schreibt gepufferte Events in den Speicher
+
+### StorageInterface und FileStorage
+
+Das Interface definiert die Speichermethoden, FileStorage implementiert die Speicherung in Dateien.
+
+**Hauptoperationen:**
+- `store()`: Speichert Events
+- `retrieve()`: Ruft Events mit Filtern ab
+- `clear()`: Löscht alle gespeicherten Daten
+
+### AnalyticsInitializer (AnalyticsInitializer.php)
+
+Konfiguriert und initialisiert den Analytics-Service beim Anwendungsstart.
+
+**Konfigurationsoptionen:**
+- Aktivierung/Deaktivierung
+- Auto-Flush und Batch-Größe
+- Storage-Typ und Pfad
+
+### AnalyticsMiddleware (AnalyticsMiddleware.php)
+
+HTTP-Middleware zum automatischen Tracking von Requests und Responses.
+
+### AnalyticsDashboard (AnalyticsDashboard.php)
+
+Stellt Methoden für Datenanalyse und -aggregation bereit:
+- `getEventStats()`: Ereignisstatistiken
+- `getTopPages()`: Meistbesuchte Seiten
+- `getUserStats()`: Benutzerstatistiken
+- `getErrorStats()`: Fehlerstatistiken
+- `getPerformanceStats()`: Leistungsmetriken
+
+### Events
+
+Vordefinierte Event-Typen:
+- `AnalyticsEvent`: Basis-Event-Klasse
+- `PageViewEvent`: Speziell für Seitenaufrufe
+
+### Controllers
+
+`AdminAnalyticsController`: Stellt das Admin-Dashboard bereit mit:
+- Übersichtsseite
+- Seitenstatistiken
+- Fehlerstatistiken
+- Leistungsstatistiken
+
+### Console
+
+`AnalyticsClearCommand`: Konsolenbefehl zum Löschen von Analytics-Daten.
+
+## Konfiguration
+
+Die Konfiguration erfolgt in `src/Config/analytics.php` mit folgenden Optionen:
+
+```php
+return [
+    'enabled' => true,           // Aktiviert/deaktiviert das Tracking
+    'auto_flush' => true,         // Automatisches Speichern nach Batch-Größe
+    'batch_size' => 50,           // Anzahl Events pro Batch
+    'storage' => 'file',          // Storage-Backend
+    'storage_path' => '...',      // Speicherpfad
+    'anonymize_ip' => true,       // IP-Anonymisierung
+    'track_events' => [...]       // Zu trackende Events
+];
+```
+
+## Verwendung
+
+### Basis-Tracking
+
+```php
+// Event tracken
+$analytics->track('button_click', ['button' => 'signup']);
+
+// Seitenaufruf tracken
+$analytics->page('/dashboard', ['section' => 'analytics']);
+
+// Benutzer identifizieren
+$analytics->user('user123', ['plan' => 'premium']);
+```
+
+### Middleware einrichten
+
+```php
+$this->addMiddleware(App\Framework\Analytics\AnalyticsMiddleware::class);
+```
+
+### Eigene Middleware hinzufügen
+
+```php
+$analyticsManager->addMiddleware(function(array $event) {
+    // Daten verarbeiten oder filtern
+    return $event;
+});
+```
+
+## Datenschutz
+
+Das System bietet integrierte Funktionen zur Anonymisierung personenbezogener Daten:
+- IP-Adressen-Anonymisierung (letztes Oktett wird entfernt)
+- Konfigurierbare Filterung sensibler Daten durch Middleware
+
+## Erweiterbarkeit
+
+### Eigene Storage-Provider
+
+Implementieren Sie das `StorageInterface` für benutzerdefinierte Speicherlösungen:
+
+```php
+class CustomStorage implements StorageInterface
+{
+    public function store(array $events): void { /* ... */ }
+    public function retrieve(array $filters = []): array { /* ... */ }
+    public function clear(): void { /* ... */ }
+}
+```
+
+### Event-Typen erweitern
+
+Erstellen Sie benutzerdefinierte Event-Klassen, die von `AnalyticsEvent` erben:
+
+```php
+class CustomEvent extends AnalyticsEvent
+{
+    public function __construct(string $customData, array $additionalProps = [])
+    {
+        parent::__construct('custom_event', 
+            array_merge(['custom_data' => $customData], $additionalProps));
+    }
+}
+```
diff --git a/docs/framework/analytics/architecture.md b/docs/framework/analytics/architecture.md
new file mode 100644
index 00000000..f49ec68f
--- /dev/null
+++ b/docs/framework/analytics/architecture.md
@@ -0,0 +1,102 @@
+# Analytics-Framework: Architektur
+
+## Überblick
+
+Das Analytics-Framework verwendet eine Schichtenarchitektur mit klaren Verantwortlichkeiten:
+
+```
+┌─────────────────────────────────────────────────────┐
+│                 Öffentliche API                      │
+│                  (Analytics)                         │
+└───────────────────────┬─────────────────────────────┘
+                        │
+┌───────────────────────▼─────────────────────────────┐
+│              Event-Verarbeitung                      │
+│             (AnalyticsManager)                       │
+└───────────────────────┬─────────────────────────────┘
+                        │
+         ┌──────────────┴──────────────┐
+         │                             │
+┌────────▼─────────┐         ┌─────────▼────────┐
+│   Middleware     │         │  Storage-Layer   │
+│   (Pipeline)     │         │ (StorageInterface)│
+└──────────────────┘         └──────────────────┘
+```
+
+## Komponenten im Detail
+
+### Analytics (Frontend)
+
+Bietet eine benutzerfreundliche API für Tracking-Operationen. Diese Klasse ist der primäre Einstiegspunkt für Anwendungscode und abstrahiert die Komplexität der Eventverarbeitung.
+
+Verantwortlichkeiten:
+- Bereitstellung der öffentlichen API (`track`, `page`, `user`, `error`)
+- Integration mit dem Event-Dispatcher des Frameworks
+- Typ-Konvertierung zwischen benutzerdefinierten Ereignissen und dem internen Datenformat
+
+### AnalyticsManager (Verarbeitung)
+
+Der Manager ist das Herzstück des Systems und verantwortlich für:
+- Anwendung von Middleware-Transformationen auf Events
+- Eventpufferung für effiziente Speicherung
+- Verwaltung der Konfiguration
+- Steuerung des Storage-Layers
+
+Der Manager implementiert einen Event-Buffer, der Daten sammelt und bei Erreichen einer konfigurierbaren Größe automatisch speichert.
+
+### Middleware-System
+
+Eine Kette von Verarbeitungsfunktionen, die auf jedes Event angewendet werden:
+- Datenfilterung und -transformation
+- Anonymisierung persönlicher Daten
+- Validierung und Anreicherung von Events
+
+Jede Middleware kann Events modifizieren oder komplett verwerfen.
+
+### Storage-Layer
+
+Abstraktion für verschiedene Speichermethoden durch das `StorageInterface`:
+
+```php
+interface StorageInterface
+{
+    public function store(array $events): void;
+    public function retrieve(array $filters = []): array;
+    public function clear(): void;
+}
+```
+
+Implementierungen:
+- `FileStorage`: Speichert Events in JSON-Dateien mit täglicher Rotation
+- Erweiterbar für andere Backends (Datenbank, Redis, etc.)
+
+### HTTP-Integration
+
+`AnalyticsMiddleware` integriert Analytics in den HTTP-Request-Lifecycle:
+- Tracking von eingehenden Requests
+- Erfassung von Antwortzeiten und Statuscodes
+- Fehlererfassung bei Exceptions
+
+### Admin-Dashboard
+
+`AnalyticsDashboard` und `AdminAnalyticsController` bieten:
+- Datenaggregation und -analyse
+- Visualisierung von Metriken
+- Filterung nach Zeiträumen
+- Verschiedene spezialisierte Ansichten (Seiten, Fehler, Performance)
+
+## Datenfluss
+
+1. Event wird durch `Analytics::track()` oder ähnliche Methoden erstellt
+2. `AnalyticsManager` wendet Middleware-Pipeline an
+3. Event wird zum Buffer hinzugefügt
+4. Bei Buffer-Füllung oder explizitem `flush()` werden Events an Storage übergeben
+5. Storage speichert Events im konfigurierten Backend
+6. `AnalyticsDashboard` ruft Daten bei Bedarf vom Storage ab und aggregiert sie
+
+## Erweiterungspunkte
+
+- **Storage-Provider**: Neue Implementierungen von `StorageInterface`
+- **Middleware**: Funktionen für Filterung/Transformation
+- **Event-Typen**: Spezialisierte Event-Klassen für typsicheres Tracking
+- **Dashboard-Views**: Zusätzliche Visualisierungen und Berichte
diff --git a/docs/framework/analytics/index.md b/docs/framework/analytics/index.md
new file mode 100644
index 00000000..887c99ee
--- /dev/null
+++ b/docs/framework/analytics/index.md
@@ -0,0 +1,114 @@
+# Analytics-Framework
+
+> **Dokumentationshinweis:** Diese Dokumentation ist vollständig aktualisiert und stellt die aktuelle Implementierung des Analytics-Frameworks korrekt dar.
+
+## Übersicht
+
+Das Analytics-Framework ist ein eigenständiges Tracking- und Analysesystem, das vollständig in die Anwendung integriert ist und ohne externe Dienste auskommt. Es ermöglicht die Erfassung, Speicherung und Analyse von:
+
+- Benutzeraktivitäten (Seitenaufrufe, Interaktionen)
+- Systemereignissen (Anwendungsstart, Fehler)
+- Leistungsdaten (Speicherverbrauch, Ausführungszeit, Datenbankabfragen)
+
+## Hauptkomponenten
+
+### Analytics-Klasse
+
+Die zentrale API für Tracking-Operationen:
+
+```php
+// Klasse initialisieren
+$analytics = new Analytics($analyticsManager, $eventDispatcher);
+
+// Event tracken
+$analytics->track('event_name', ['property' => 'value']);
+
+// Seite tracken
+$analytics->page('/pfad/zur/seite', ['eigenschaft' => 'wert']);
+
+// Benutzer identifizieren
+$analytics->user('user_id', ['eigenschaft' => 'wert']);
+
+// Fehler tracken
+$analytics->error($exception);
+```
+
+### AnalyticsManager
+
+Verarbeitet und speichert Events:
+
+- Wendet Middleware auf Events an
+- Puffert Events für effiziente Speicherung
+- Verwaltet die Konfiguration
+- Steuert die Speicherung in verschiedenen Backends
+
+### Storage-System
+
+Basierend auf dem `StorageInterface` mit verschiedenen Implementierungen:
+
+- `FileStorage`: Speichert Events in Dateien
+- Erweiterbar für Datenbank, Redis oder andere Backends
+
+### Middleware-System
+
+```php
+$analyticsManager->addMiddleware(function(array $event) {
+    // Event verarbeiten oder filtern
+    return $event; // oder null um zu verwerfen
+});
+```
+
+### HTTP-Middleware
+
+Automatisches Tracking von HTTP-Requests und -Responses:
+
+```php
+// In Bootstrap oder Application-Klasse
+$app->addMiddleware(AnalyticsMiddleware::class);
+```
+
+### Dashboard und Berichterstattung
+
+Das `AnalyticsDashboard` bietet Methoden zur Datenanalyse:
+
+- `getEventStats()`: Statistiken zu Events
+- `getTopPages()`: Meistbesuchte Seiten
+- `getUserStats()`: Benutzerstatistiken
+- `getErrorStats()`: Fehlerstatistiken
+- `getPerformanceStats()`: Leistungsmetriken
+
+Das Admin-Dashboard ist unter `/admin/analytics` verfügbar.
+
+### Konsolen-Befehle
+
+```bash
+# Analytics-Daten löschen
+php console analytics:clear [--force]
+```
+
+## Integration
+
+### Service-Container
+
+Der Analytics-Service wird automatisch registriert und kann per Dependency Injection verwendet werden:
+
+```php
+public function __construct(private readonly Analytics $analytics) {}
+```
+
+### Event-Integration
+
+Standardmäßig werden folgende Anwendungsereignisse getrackt:
+
+- Anwendungsstart (`application_booted`)
+- Fehlerbehandlung (`error_occurred`)
+- Request-Verarbeitung (`request_started`, `request_completed`)
+
+## Konfiguration
+
+Detaillierte Konfigurationsoptionen finden Sie in der [Framework-README](/Framework/Analytics1/README.md).
+
+## Weitere Informationen
+
+- [Framework-Erweiterungsmuster](/docs/framework/ERWEITERUNGSPATTERN.md)
+- [Modul-Checkliste](/docs/framework/MODUL-CHECKLISTE.md)
diff --git a/docs/framework/analytics/migration.md b/docs/framework/analytics/migration.md
new file mode 100644
index 00000000..b4b6e5f0
--- /dev/null
+++ b/docs/framework/analytics/migration.md
@@ -0,0 +1,160 @@
+# Analytics-Framework: Migrationsleitfaden
+
+## Von Version 1.x zu 2.x
+
+### Überblick der Änderungen
+
+Die Version 2.x des Analytics-Frameworks führt mehrere wichtige Verbesserungen und Änderungen ein:
+
+- **Typsicherheit**: Neue Event-Klassen statt Arrays
+- **Dependency Injection**: Verbesserte Integration mit dem Container
+- **Storage-Abstraktion**: Flexiblere Speichermethoden
+- **Fehlerbehandlung**: Robustere Exception-Handling
+- **Middleware-System**: Standardisierte Middleware-Pipeline
+
+### Notwendige Migrationsschritte
+
+#### 1. Konfiguration aktualisieren
+
+**Alt (1.x):**
+```php
+return [
+    'enabled' => true,
+    'auto_flush' => true,
+    'batch_size' => 50,
+    'storage' => 'file',
+    'storage_path' => '/pfad/zum/speicher',
+];
+```
+
+**Neu (2.x):**
+```php
+return [
+    'enabled' => true,
+    'auto_flush' => true,
+    'batch_size' => 50,
+    'storage_driver' => 'file',  // Umbenannt
+    'storage_config' => [        // Neue Struktur
+        'path' => '/pfad/zum/speicher',
+    ],
+    'excluded_paths' => [],      // Neue Option
+    'excluded_user_agents' => [], // Neue Option
+    'max_file_size' => 10 * 1024 * 1024, // Neue Option
+];
+```
+
+#### 2. Event-Objekte (falls genutzt)
+
+**Alt (1.x):**
+```php
+$analytics->track('custom_event', ['property' => 'value']);
+```
+
+**Neu (2.x) - Option 1 (abwärtskompatibel):**
+```php
+// Weiterhin unterstützt
+$analytics->track('custom_event', ['property' => 'value']);
+```
+
+**Neu (2.x) - Option 2 (typsicher):**
+```php
+use App\Framework\Analytics\Events\CustomEvent;
+
+$event = new CustomEvent('wert', ['weitere' => 'daten']);
+$analytics->trackEvent($event);
+```
+
+#### 3. Eigene Storage-Provider
+
+**Alt (1.x):**
+```php
+class CustomStorage implements StorageInterface
+{
+    public function store(array $events): void
+    {
+        // Implementation
+    }
+
+    public function retrieve(array $filters = []): array
+    {
+        // Implementation
+    }
+
+    public function clear(): void
+    {
+        // Implementation
+    }
+}
+```
+
+**Neu (2.x):**
+```php
+use Psr\Log\LoggerInterface;
+
+class CustomStorage implements StorageInterface
+{
+    public function __construct(
+        private readonly array $config,
+        private readonly LoggerInterface $logger
+    ) {}
+
+    public function store(array $events): void
+    {
+        try {
+            // Implementation mit Fehlerbehandlung
+        } catch (\Exception $e) {
+            $this->logger->error('Storage error', ['exception' => $e]);
+            throw new StorageException('Failed to store events', 0, $e);
+        }
+    }
+
+    // Andere Methoden analog
+}
+```
+
+#### 4. Middleware anpassen
+
+**Alt (1.x):**
+```php
+$analyticsManager->addMiddleware(function(array $event) {
+    // Verarbeitung
+    return $event;
+});
+```
+
+**Neu (2.x) - Option 1 (abwärtskompatibel):**
+```php
+// Weiterhin unterstützt
+$analyticsManager->addMiddleware(function(array $event) {
+    // Verarbeitung
+    return $event;
+});
+```
+
+**Neu (2.x) - Option 2 (typsicher):**
+```php
+use App\Framework\Analytics\Middleware\AnalyticsMiddleware;
+use App\Framework\Analytics\Events\AnalyticsEvent;
+
+class CustomMiddleware implements AnalyticsMiddleware
+{
+    public function process(AnalyticsEvent $event): ?AnalyticsEvent
+    {
+        // Verarbeitung
+        return $event;
+    }
+}
+
+// Registrierung
+$analyticsManager->addMiddleware(new CustomMiddleware());
+```
+
+### Automatisierte Tests
+
+Führen Sie die folgenden Tests durch, um sicherzustellen, dass die Migration erfolgreich war:
+
+```bash
+php console test:run --group=analytics
+```
+
+Weitere Informationen zur Migration finden Sie in den Änderungsprotokollen im Quellcode-Repository.
diff --git a/docs/framework/analytics/usage.md b/docs/framework/analytics/usage.md
new file mode 100644
index 00000000..d5363cb2
--- /dev/null
+++ b/docs/framework/analytics/usage.md
@@ -0,0 +1,269 @@
+# Analytics-Framework: Anwendungsbeispiele
+
+## Grundlegende Verwendung
+
+### Events tracken
+
+```php
+// Über Dependency Injection
+public function __construct(private readonly Analytics $analytics) {}
+
+// Einfaches Event tracken
+$this->analytics->track('login_attempt', [
+    'success' => true,
+    'user_type' => 'admin',
+    'method' => 'password'
+]);
+
+// Seitenaufruf tracken
+$this->analytics->page('/produkte/kategorie/elektronik', [
+    'referrer' => 'homepage',
+    'search_query' => 'smartphones'
+]);
+
+// Benutzer identifizieren
+$this->analytics->user($user->getId(), [
+    'email' => $user->getEmail(),
+    'plan' => $user->getSubscriptionPlan(),
+    'registered_since' => $user->getCreatedAt()->format('Y-m-d')
+]);
+```
+
+### Fehler tracken
+
+```php
+try {
+    // Fehleranfälliger Code
+    $result = $this->riskyOperation();
+    return $result;
+} catch (\Exception $e) {
+    // Fehler tracken
+    $this->analytics->error($e);
+
+    // Fehler behandeln
+    $this->logger->error($e->getMessage());
+    return $this->fallbackOperation();
+}
+```
+
+### Performance tracken
+
+```php
+// Manuelles Performance-Tracking
+$startTime = microtime(true);
+$startMemory = memory_get_usage();
+
+// Operation durchführen
+$result = $this->heavyOperation();
+
+// Performance-Metriken tracken
+$this->analytics->performance([
+    'operation' => 'heavy_operation',
+    'execution_time' => microtime(true) - $startTime,
+    'memory_used' => memory_get_usage() - $startMemory,
+    'result_size' => is_countable($result) ? count($result) : 0
+]);
+```
+
+## Erweiterte Anwendungsfälle
+
+### Benutzerdefinierte Middleware
+
+```php
+// In einem Service Provider oder Initializer
+public function initialize(AnalyticsManager $manager): void
+{
+    // DSGVO-Middleware zur Anonymisierung personenbezogener Daten
+    $manager->addMiddleware(function(array $event) {
+        // E-Mail-Adressen anonymisieren
+        if (isset($event['properties']['email'])) {
+            $parts = explode('@', $event['properties']['email']);
+            if (count($parts) === 2) {
+                $event['properties']['email'] = substr($parts[0], 0, 1) . 
+                    '***@' . $parts[1];
+            }
+        }
+
+        // Passwörter und Tokens entfernen
+        foreach (['password', 'token', 'api_key', 'secret'] as $key) {
+            if (isset($event['properties'][$key])) {
+                $event['properties'][$key] = '[redacted]';
+            }
+        }
+
+        return $event;
+    });
+
+    // Spam-Filter
+    $manager->addMiddleware(function(array $event) {
+        // Zu viele Events von einem Benutzer filtern
+        static $userCounts = [];
+        $userId = $event['user_id'] ?? $event['session_id'] ?? null;
+
+        if ($userId) {
+            $userCounts[$userId] = ($userCounts[$userId] ?? 0) + 1;
+
+            // Mehr als 100 Events pro Session ist verdächtig
+            if ($userCounts[$userId] > 100) {
+                return null; // Event verwerfen
+            }
+        }
+
+        return $event;
+    });
+}
+```
+
+### Integration mit dem Domain-Layer
+
+```php
+// In einem Domain-Service
+namespace App\Domain\Shop\Services;
+
+use App\Framework\Analytics\Analytics;
+
+class ProductService
+{
+    public function __construct(private readonly Analytics $analytics) {}
+
+    public function viewProduct(string $productId, ?string $userId): Product
+    {
+        $product = $this->productRepository->find($productId);
+
+        if (!$product) {
+            throw new ProductNotFoundException($productId);
+        }
+
+        // Produktansicht tracken
+        $this->analytics->track('product_view', [
+            'product_id' => $product->getId(),
+            'product_name' => $product->getName(),
+            'product_price' => $product->getPrice(),
+            'product_category' => $product->getCategory()->getName(),
+            'in_stock' => $product->isInStock()
+        ], $userId);
+
+        return $product;
+    }
+
+    public function addToCart(string $productId, int $quantity, ?string $userId): Cart
+    {
+        // Implementation...
+
+        // Event tracken
+        $this->analytics->track('add_to_cart', [
+            'product_id' => $productId,
+            'quantity' => $quantity,
+            'cart_value' => $cart->getTotalValue()
+        ], $userId);
+
+        return $cart;
+    }
+}
+```
+
+### Verwendung im Controller
+
+```php
+namespace App\Application\Controllers;
+
+use App\Framework\Analytics\Analytics;
+use App\Framework\Http\Request;
+use App\Framework\Http\Response;
+use App\Framework\Attributes\Route;
+
+class CheckoutController
+{
+    public function __construct(
+        private readonly Analytics $analytics,
+        private readonly CheckoutService $checkoutService
+    ) {}
+
+    #[Route('/checkout/complete', method: 'POST')]
+    public function completeCheckout(Request $request): Response
+    {
+        $userId = $request->getSession()->get('user_id');
+        $cartId = $request->getSession()->get('cart_id');
+
+        try {
+            $order = $this->checkoutService->completeCheckout($cartId, $userId);
+
+            // Erfolgreichen Checkout tracken
+            $this->analytics->track('checkout_complete', [
+                'order_id' => $order->getId(),
+                'order_value' => $order->getTotalValue(),
+                'items_count' => count($order->getItems()),
+                'payment_method' => $order->getPaymentMethod(),
+                'shipping_method' => $order->getShippingMethod()
+            ], $userId);
+
+            return new Response([
+                'success' => true,
+                'order_id' => $order->getId()
+            ], 200);
+        } catch (\Exception $e) {
+            // Fehler beim Checkout tracken
+            $this->analytics->track('checkout_error', [
+                'error' => $e->getMessage(),
+                'cart_id' => $cartId
+            ], $userId);
+
+            // Auch den Exception-Stack tracken
+            $this->analytics->error($e);
+
+            return new Response([
+                'success' => false,
+                'error' => $e->getMessage()
+            ], 400);
+        }
+    }
+}
+```
+
+## Analyse der Daten
+
+### Dashboard-Controller
+
+```php
+namespace App\Application\Controllers;
+
+use App\Framework\Analytics\AnalyticsDashboard;
+use App\Framework\Http\Request;
+use App\Framework\Http\Response;
+use App\Framework\View\ViewRenderer;
+use App\Framework\Attributes\Route;
+
+class AnalyticsDashboardController
+{
+    public function __construct(
+        private readonly AnalyticsDashboard $dashboard,
+        private readonly ViewRenderer $viewRenderer
+    ) {}
+
+    #[Route('/admin/analytics/conversion')]
+    public function conversionReport(Request $request): Response
+    {
+        $from = $request->getQueryParam('from');
+        $to = $request->getQueryParam('to');
+
+        // Benutzerdefinierte Analyse für Conversion-Funnel
+        $pageViews = $this->dashboard->getEventCountByType('page_view', $from, $to);
+        $productViews = $this->dashboard->getEventCountByType('product_view', $from, $to);
+        $addToCarts = $this->dashboard->getEventCountByType('add_to_cart', $from, $to);
+        $checkouts = $this->dashboard->getEventCountByType('checkout_complete', $from, $to);
+
+        // Conversion-Raten berechnen
+        $data = [
+            'total_visitors' => $pageViews,
+            'product_view_rate' => $pageViews > 0 ? $productViews / $pageViews : 0,
+            'add_to_cart_rate' => $productViews > 0 ? $addToCarts / $productViews : 0,
+            'checkout_rate' => $addToCarts > 0 ? $checkouts / $addToCarts : 0,
+            'overall_conversion' => $pageViews > 0 ? $checkouts / $pageViews : 0,
+            'from_date' => $from,
+            'to_date' => $to
+        ];
+
+        return $this->viewRenderer->render('admin/analytics/conversion', $data);
+    }
+}
+```
diff --git a/docs/framework/core/README.md b/docs/framework/core/README.md
new file mode 100644
index 00000000..4435e80a
--- /dev/null
+++ b/docs/framework/core/README.md
@@ -0,0 +1,45 @@
+# Core-Modul Dokumentation
+
+## Übersicht
+
+Das Core-Modul bildet das Herzstück des Frameworks und stellt grundlegende Funktionalitäten bereit, die von anderen Modulen genutzt werden.
+
+## Hauptkomponenten
+
+### Events und EventDispatcher
+
+Das Event-System ermöglicht die Kommunikation zwischen Komponenten über einen zentralen Event-Bus.
+
+**Kernklassen:**
+- `EventDispatcher`: Zentraler Service zum Registrieren und Auslösen von Events
+- Bekannte Events:
+  - `ApplicationBooted`
+  - `ErrorOccurred`
+  - `BeforeHandleRequest`
+  - `AfterHandleRequest`
+
+**Beispielverwendung:**
+```php
+// Event-Handler registrieren
+$eventDispatcher->addHandler('App\Framework\Core\Events\ApplicationBooted', function($event) {
+    // Event verarbeiten
+});
+```
+
+### PathProvider
+
+Stellt Pfadinformationen für verschiedene Bereiche der Anwendung bereit.
+
+**Hauptfunktionen:**
+- `getDataPath()`: Liefert Pfade zu Datenverzeichnissen
+
+## Integration mit anderen Modulen
+
+Das Core-Modul wird von vielen anderen Modulen verwendet, wie z.B.:
+
+- **Analytics-Modul**: Nutzt den EventDispatcher zum Tracking von Systemereignissen
+- **DI-Container**: Nutzt Core-Komponenten für die Initialisierung von Services
+
+## Architektur
+
+Das Core-Modul folgt einer ereignisgesteuerten Architektur, bei der Komponenten über Events miteinander kommunizieren können, anstatt direkte Abhängigkeiten zu haben.
diff --git a/docs/framework/di/README.md b/docs/framework/di/README.md
new file mode 100644
index 00000000..e961c8c6
--- /dev/null
+++ b/docs/framework/di/README.md
@@ -0,0 +1,89 @@
+# Dependency Injection Modul
+
+## Übersicht
+
+Das DI-Modul implementiert ein Dependency-Injection-Container-System, das die automatische Auflösung und Verwaltung von Abhängigkeiten ermöglicht.
+
+## Hauptkomponenten
+
+### Container
+
+Der zentrale Service-Container, der Instanzen erstellt und verwaltet.
+
+**Hauptfunktionen:**
+- Service-Erstellung und -Auflösung
+- Singleton-Verwaltung
+- Rekursive Abhängigkeitsauflösung
+
+### Initializer-Attribut
+
+Das `#[Initializer]`-Attribut kennzeichnet Klassen, die Services im Container registrieren können.
+
+**Beispiel:**
+```php
+#[Initializer]
+readonly class AnalyticsInitializer
+{
+    public function __invoke(Container $container): Analytics
+    {
+        // Service erstellen und konfigurieren
+        return $analytics;
+    }
+}
+```
+
+## Verwendung
+
+### Service definieren
+
+```php
+// Service-Interface
+interface MyServiceInterface
+{
+    public function doSomething(): void;
+}
+
+// Konkrete Implementierung
+class MyService implements MyServiceInterface
+{
+    public function doSomething(): void
+    {
+        // Implementierung
+    }
+}
+```
+
+### Service registrieren
+
+```php
+#[Initializer]
+class MyServiceInitializer
+{
+    public function __invoke(Container $container): MyServiceInterface
+    {
+        return new MyService();
+    }
+}
+```
+
+### Service verwenden
+
+```php
+class MyController
+{
+    public function __construct(
+        private readonly MyServiceInterface $myService
+    ) {}
+
+    public function action(): void
+    {
+        $this->myService->doSomething();
+    }
+}
+```
+
+## Prinzipien
+
+- **Automatische Auflösung**: Abhängigkeiten werden anhand von Typ-Hints automatisch aufgelöst
+- **Lazy Loading**: Services werden erst erstellt, wenn sie benötigt werden
+- **Singleton-Modus**: Standardmäßig werden Services als Singletons verwaltet
diff --git a/docs/framework/http/README.md b/docs/framework/http/README.md
new file mode 100644
index 00000000..4e8e3f53
--- /dev/null
+++ b/docs/framework/http/README.md
@@ -0,0 +1,92 @@
+# HTTP-Modul Dokumentation
+
+## Übersicht
+
+Das HTTP-Modul stellt Komponenten für die Verarbeitung von HTTP-Anfragen und -Antworten bereit.
+
+## Hauptkomponenten
+
+### Request
+
+Repräsentiert eine HTTP-Anfrage mit Methoden zum Zugriff auf:
+- HTTP-Methode (`getMethod()`)
+- Pfad (`getPath()`)
+- Query-Parameter (`getQueryParams()`)
+- Request-Body
+- Headers
+
+### Response
+
+Repräsentiert eine HTTP-Antwort mit:
+- Status-Code (`getStatusCode()`)
+- Headers
+- Body
+
+### Middleware
+
+Ein Interface für HTTP-Middleware-Komponenten, die die Request-Verarbeitung verändern können:
+
+```php
+interface Middleware
+{
+    public function process(Request $request, callable $next): Response;
+}
+```
+
+**Beispiel-Middleware:**
+```php
+class AnalyticsMiddleware implements Middleware
+{
+    public function __construct(
+        private readonly Analytics $analytics
+    ) {}
+
+    public function process(Request $request, callable $next): Response
+    {
+        // Request tracken
+        $this->analytics->track('http_request', [
+            'method' => $request->getMethod(),
+            'path' => $request->getPath(),
+        ]);
+
+        // Request weiterleiten
+        $response = $next($request);
+
+        // Response tracken
+        $this->analytics->track('http_response', [
+            'status_code' => $response->getStatusCode(),
+        ]);
+
+        return $response;
+    }
+}
+```
+
+## Integration mit anderen Modulen
+
+- **Router**: Routing von HTTP-Requests zu Controllers
+- **Analytics**: Tracking von HTTP-Requests und -Responses
+- **Validation**: Validierung von Request-Daten
+
+## Middlewares registrieren
+
+In der Anwendungsklasse:
+
+```php
+$this->addMiddleware(LoggingMiddleware::class);
+$this->addMiddleware(AnalyticsMiddleware::class);
+$this->addMiddleware(AuthenticationMiddleware::class);
+```
+
+## Responses erzeugen
+
+```php
+// JSON-Response
+return new JsonResponse(['success' => true]);
+
+// HTML-Response
+return new HtmlResponse('<html><body>Hello World</body></html>');
+
+// Redirect
+return new RedirectResponse('/dashboard');
+```
diff --git a/docs/framework/index.md b/docs/framework/index.md
new file mode 100644
index 00000000..58a1a271
--- /dev/null
+++ b/docs/framework/index.md
@@ -0,0 +1,42 @@
+# Framework-Dokumentation
+
+## Übersicht
+
+Diese Dokumentation beschreibt die Architektur, Komponenten und Verwendung des Framework-Kerns des Projekts.
+
+## Hauptmodule
+
+- [Analytics](/framework/analytics/README.md) - System zur Erfassung und Analyse von Anwendungsdaten
+- [Core](/framework/core/README.md) - Kernkomponenten und Event-System
+- [DI (Dependency Injection)](/framework/di/README.md) - Container und Service-Management
+- [HTTP](/framework/http/README.md) - HTTP-Request/Response-Handling
+
+## Richtlinien und Muster
+
+- [Modul-Checkliste](/framework/MODUL-CHECKLISTE.md) - Leitfaden für die Erstellung neuer Module
+- [Erweiterungsmuster](/framework/ERWEITERUNGSPATTERN.md) - Muster zur Erweiterung des Frameworks
+
+## Modulare Architektur
+
+Das Framework ist modular aufgebaut, mit klaren Verantwortlichkeiten für jedes Modul. Module kommunizieren über klar definierte Interfaces und den Event-Dispatcher.
+
+### Neues Modul erstellen
+
+Um ein neues Modul zu erstellen, folgen Sie der [Modul-Checkliste](/framework/MODUL-CHECKLISTE.md) und beachten Sie die folgenden Kernprinzipien:
+
+1. Klare Verantwortlichkeiten definieren
+2. Dependency Injection verwenden
+3. Interface-basiertes Design umsetzen
+4. Event-basierte Kommunikation nutzen
+5. Externe Abhängigkeiten minimieren
+
+### Framework erweitern
+
+Es gibt verschiedene Möglichkeiten, das Framework zu erweitern:
+
+1. **Middleware**: HTTP-Request-Pipeline erweitern
+2. **Event-Listener**: Auf System-Events reagieren
+3. **Service-Provider**: Eigene Services registrieren
+4. **Plugin-System**: Umfangreichere Erweiterungen implementieren
+
+Weitere Details finden Sie im Dokument [Erweiterungsmuster](/framework/ERWEITERUNGSPATTERN.md).
diff --git a/docs/guidelines/PERFORMANCE-GUIDELINES.md b/docs/guidelines/PERFORMANCE-GUIDELINES.md
new file mode 100644
index 00000000..21dbf67f
--- /dev/null
+++ b/docs/guidelines/PERFORMANCE-GUIDELINES.md
@@ -0,0 +1,169 @@
+# Performance-Richtlinien
+
+## Übersicht
+
+Diese Richtlinien beschreiben Best Practices für die Optimierung der Anwendungsleistung im Framework.
+
+## Grundprinzipien
+
+### 1. Frühe Optimierung vermeiden
+
+- Code zuerst korrekt und lesbar schreiben
+- Optimierungen auf Basis von Messungen durchführen
+- Performance-Engpässe mit dem Profiler identifizieren
+
+### 2. Caching strategisch einsetzen
+
+- Ergebnisse teurer Operationen cachen
+- Geeignete Cache-Invalidierungsstrategien implementieren
+- Cache-Hierarchie nutzen (Memory → Filesystem → Datenbank)
+
+```php
+// Beispiel: Strategisches Caching
+public function getExpensiveData(string $key): array
+{
+    $cacheKey = "data_{$key}";
+
+    // Prüfen, ob Daten im Cache sind
+    if ($this->cache->has($cacheKey)) {
+        return $this->cache->get($cacheKey);
+    }
+
+    // Teure Operation durchführen
+    $result = $this->performExpensiveOperation($key);
+
+    // Ergebnis cachen mit angemessener TTL
+    $this->cache->set($cacheKey, $result, 3600);
+
+    return $result;
+}
+```
+
+### 3. Lazy Loading
+
+- Ressourcen erst bei Bedarf laden
+- Schwere Abhängigkeiten verzögert initialisieren
+
+```php
+// Beispiel: Lazy Loading
+private ?ExpensiveService $expensiveService = null;
+
+private function getExpensiveService(): ExpensiveService
+{
+    if ($this->expensiveService === null) {
+        $this->expensiveService = new ExpensiveService($this->config);
+    }
+
+    return $this->expensiveService;
+}
+```
+
+### 4. Datenstrukturen optimieren
+
+- Passende Datenstrukturen für den Anwendungsfall wählen
+- Große Arrays vermeiden, wenn möglich Iteratoren oder Generatoren nutzen
+- Bei großen Datenmengen paginieren
+
+```php
+// Beispiel: Generator statt Array
+public function processLargeDataset(): Generator
+{
+    $handle = fopen($this->largeFile, 'r');
+
+    while (($line = fgets($handle)) !== false) {
+        yield $this->processLine($line);
+    }
+
+    fclose($handle);
+}
+```
+
+## Spezifische Optimierungen
+
+### Datenbankzugriffe
+
+- Anzahl der Datenbankabfragen minimieren
+- Indizes für häufige Abfragen
+- N+1 Problem vermeiden durch Eager Loading
+- Datenbankverbindungen poolen
+
+### HTTP-Anfragen
+
+- Statische Assets komprimieren und cachen
+- HTTP/2 nutzen, wenn möglich
+- Content-Kompression aktivieren
+- Browser-Caching durch geeignete Header
+
+### Speichernutzung
+
+- Große Objekte nach Gebrauch freigeben (`unset()`)
+- Zirkuläre Referenzen vermeiden
+- Bei Dateiberarbeitung auf Streaming-Ansätze setzen
+
+### Autoloading
+
+- Composer-Autoloader in Produktionsumgebung optimieren
+- Preloading für häufig verwendete Klassen nutzen
+
+```php
+// preload.php Beispiel
+<?php
+
+declare(strict_types=1);
+
+// Häufig verwendete Klassen vorladen
+require_once __DIR__ . '/Framework/Core/Application.php';
+require_once __DIR__ . '/Framework/DI/Container.php';
+require_once __DIR__ . '/Framework/Http/Request.php';
+require_once __DIR__ . '/Framework/Http/Response.php';
+```
+
+## Monitoring und Profiling
+
+### Performance messen
+
+- Kritische Code-Pfade instrumentieren
+- End-to-End Zeitmessungen durchführen
+
+```php
+// Beispiel: Performance-Messung
+$startTime = microtime(true);
+
+// Operation durchführen
+$result = $this->performOperation();
+
+$duration = microtime(true) - $startTime;
+$this->logger->debug("Operation ausgeführt in {$duration}s");
+```
+
+### Automatisiertes Monitoring
+
+- Performance-Regressions automatisch erkennen
+- Regelmäßige Lasttests durchführen
+- Kritische Pfade überwachen
+
+## Umgebungsspezifische Optimierungen
+
+### Entwicklung
+
+- Debug-Tools aktivieren
+- Performance-Optimierungen deaktivieren, die Debugging erschweren
+
+### Produktion
+
+- Opcache aktivieren und optimieren
+- Fehlerbehandlung optimieren (keine Stack Traces)
+- Logging auf nötige Informationen beschränken
+
+```php
+// Umgebungsspezifische Einstellungen
+if ($environment === 'production') {
+    ini_set('opcache.validate_timestamps', 0);
+    ini_set('display_errors', 0);
+    error_reporting(E_ERROR | E_WARNING | E_PARSE);
+} else {
+    ini_set('opcache.validate_timestamps', 1);
+    ini_set('display_errors', 1);
+    error_reporting(E_ALL);
+}
+```
diff --git a/docs/guidelines/TESTING-GUIDELINES.md b/docs/guidelines/TESTING-GUIDELINES.md
new file mode 100644
index 00000000..9875f5fe
--- /dev/null
+++ b/docs/guidelines/TESTING-GUIDELINES.md
@@ -0,0 +1,181 @@
+# Testing-Richtlinien
+
+## Übersicht
+
+Diese Richtlinien beschreiben die Standards und Best Practices für Tests im Framework.
+
+## Grundprinzipien
+
+### 1. Testarten
+
+- **Unit Tests**: Testen einzelner Komponenten isoliert
+- **Integrationstests**: Testen des Zusammenspiels mehrerer Komponenten
+- **Funktionstests**: Testen ganzer Funktionalitäten aus Benutzersicht
+
+### 2. Pest-Framework
+
+Alle Tests werden mit dem Pest-Framework geschrieben:
+
+```php
+test('Analytics::track zeichnet Events korrekt auf', function () {
+    // Arrange
+    $manager = new AnalyticsManager(['enabled' => true], new InMemoryStorage());
+    $analytics = new Analytics($manager, new EventDispatcher());
+
+    // Act
+    $analytics->track('test_event', ['key' => 'value']);
+
+    // Assert
+    expect($manager->getStorage()->retrieve())->toHaveCount(1);
+    expect($manager->getStorage()->retrieve()[0]['event'])->toBe('test_event');
+});
+```
+
+### 3. Teststruktur
+
+- Jeder Test folgt dem AAA-Prinzip: Arrange, Act, Assert
+- Tests sollten unabhängig voneinander sein
+- Tests sollten deterministisch sein (keine zufälligen Ergebnisse)
+
+## Best Practices
+
+### 1. Testabdeckung
+
+- Jede öffentliche Methode sollte getestet werden
+- Edge Cases und Fehlersituationen explizit testen
+- Fokus auf Business-Logik und kritische Pfade
+
+### 2. Mocking
+
+- Externe Abhängigkeiten mocken
+- Eigene Test-Implementierungen für Interfaces erstellen
+- Mock-Objekte nur für die spezifischen Testfälle konfigurieren
+
+```php
+// Beispiel: Test mit Mock
+test('Fehlerbehandlung bei Storage-Ausfall', function () {
+    // Arrange
+    $storage = new class implements StorageInterface {
+        public function store(array $events): void
+        {
+            throw new \RuntimeException('Storage-Fehler');
+        }
+
+        public function retrieve(array $filters = []): array
+        {
+            return [];
+        }
+
+        public function clear(): void
+        {
+        }
+    };
+
+    $manager = new AnalyticsManager(['enabled' => true], $storage);
+
+    // Act & Assert
+    expect(fn() => $manager->flush())->toThrow(\RuntimeException::class);
+});
+```
+
+### 3. Fixtures und Factories
+
+- Testdaten mit Factories erstellen
+- Komplexe Objekte über Helpers aufbauen
+- Wiederverwendbare Fixtures für ähnliche Tests
+
+```php
+// Beispiel: Test-Factory
+function createAnalyticsManager(array $config = []): AnalyticsManager
+{
+    $defaultConfig = ['enabled' => true, 'auto_flush' => false];
+    return new AnalyticsManager(
+        array_merge($defaultConfig, $config),
+        new InMemoryStorage()
+    );
+}
+
+test('Auto-Flush funktioniert korrekt', function () {
+    // Arrange
+    $manager = createAnalyticsManager(['auto_flush' => true, 'batch_size' => 2]);
+
+    // Act
+    $manager->track('event1', []);
+    $manager->track('event2', []);
+
+    // Assert
+    expect($manager->getStorage()->retrieve())->toHaveCount(2);
+});
+```
+
+### 4. Datenbankzugriffe
+
+- In Unit-Tests Datenbankzugriffe vermeiden oder mocken
+- In Integrationstests separate Testdatenbank verwenden
+- Testdatenbank nach Tests zurücksetzen
+
+### 5. Asynchrone Tests
+
+- Timeouts für asynchrone Tests setzen
+- Auf Async-Events warten, statt feste Wartezeiten
+
+## Testorganisation
+
+### 1. Dateistruktur
+
+- Tests in `/tests`-Verzeichnis mit gleicher Struktur wie `/src`
+- Dateinamen mit `Test`-Suffix
+
+### 2. Testgruppen
+
+- Tests mit Attributen in Gruppen einteilen
+- Langsame Tests markieren
+
+```php
+#[Group('analytics')]
+#[Group('slow')]
+test('große Datenmenge verarbeiten', function () {
+    // Test mit vielen Daten
+});
+```
+
+## CI/CD-Integration
+
+- Tests in CI-Pipeline automatisiert ausführen
+- Testabdeckung messen und überwachen
+- Pull Requests nur mit erfolgreichen Tests mergen
+
+## Fehlersuche
+
+### 1. Debugging-Techniken
+
+- Pest-Debugging aktivieren mit `->dump()`
+- PHPUnit-Assertions für detaillierte Fehlermeldungen
+
+```php
+test('komplexes Objekt validieren', function () {
+    $result = processData();
+
+    // Bei Fehlern Kontext ausgeben
+    if (!expect($result->isValid())->toBeTrue()->isSuccess()) {
+        dump($result->getErrors());
+    }
+});
+```
+
+### 2. Problematische Tests
+
+- Flaky Tests identifizieren und beheben
+- Tests isolieren mit `only` oder `skip`
+
+```php
+test('problematischer Test', function () {
+    // Test-Code
+})->skip('Wird untersucht');
+```
+
+## Zusammenfassung
+
+- Tests sind ein integraler Bestandteil der Codebase
+- Qualität und Wartbarkeit der Tests sind genauso wichtig wie die des Produktionscodes
+- Tests dienen als lebende Dokumentation der Funktionalität
diff --git a/docs/guidelines/index.md b/docs/guidelines/index.md
new file mode 100644
index 00000000..605610b9
--- /dev/null
+++ b/docs/guidelines/index.md
@@ -0,0 +1,43 @@
+# Entwicklungsrichtlinien
+
+## Übersicht
+
+Diese Richtlinien bieten Best Practices und Standards für die Entwicklung innerhalb des Projekts. Sie helfen, qualitativ hochwertigen, wartbaren und leistungsfähigen Code zu schreiben.
+
+## Verfügbare Richtlinien
+
+- [Performance-Richtlinien](/guidelines/PERFORMANCE-GUIDELINES.md) - Optimierung der Anwendungsleistung
+- [Testing-Richtlinien](/guidelines/TESTING-GUIDELINES.md) - Standards und Best Practices für Tests
+
+## Performance-Optimierung
+
+Leistungsoptimierung ist ein wichtiger Aspekt der Anwendungsentwicklung. Die [Performance-Richtlinien](/guidelines/PERFORMANCE-GUIDELINES.md) bieten Einblicke in:
+
+- Strategisches Caching
+- Lazy Loading
+- Optimierung von Datenbankabfragen
+- Effiziente Datenstrukturen
+- Speichernutzung
+
+## Teststrategien
+
+Testen ist ein integraler Bestandteil des Entwicklungsprozesses. Die [Testing-Richtlinien](/guidelines/TESTING-GUIDELINES.md) decken folgende Themen ab:
+
+- Unit Tests mit Pest-Framework
+- Integrationstests
+- Test-Fixtures und Factories
+- Mocking-Strategien
+- Testorganisation und -struktur
+
+## Anwendung der Richtlinien
+
+Diese Richtlinien sollten in allen Phasen der Entwicklung berücksichtigt werden:
+
+1. **Planungsphase**: Frühzeitige Berücksichtigung von Performance und Testbarkeit
+2. **Implementierungsphase**: Anwendung der Best Practices während der Entwicklung
+3. **Review-Phase**: Überprüfung des Codes anhand der Richtlinien
+4. **Refactoring**: Verbesserung bestehenden Codes gemäß den Richtlinien
+
+## Continuous Improvement
+
+Diese Richtlinien werden kontinuierlich verbessert und aktualisiert. Wenn Sie Vorschläge zur Verbesserung haben, zögern Sie nicht, diese einzubringen.
diff --git a/docs/index.md b/docs/index.md
new file mode 100644
index 00000000..ee0b4e55
--- /dev/null
+++ b/docs/index.md
@@ -0,0 +1,35 @@
+# Projekt-Dokumentation
+
+## Willkommen zur Projektdokumentation
+
+Diese Dokumentation bietet umfassende Informationen zu Coding-Standards, Architektur, Best Practices und Framework-Komponenten des Projekts.
+
+## Schnellzugriff
+
+- [Coding-Guidelines](/standards/CODING-GUIDELINES.md)
+- [Sicherheitsrichtlinien](/standards/SICHERHEITS-GUIDELINES.md)
+- [Projektstruktur](/architecture/STRUKTUR-DOKUMENTATION.md)
+- [Performance-Optimierung](/guidelines/PERFORMANCE-GUIDELINES.md)
+- [KI-Assistent Einrichtung](/ai/EINRICHTUNG-PHPSTORM.md)
+
+## Dokumentationsstruktur
+
+Die Dokumentation ist in verschiedene Bereiche unterteilt:
+
+- **Standards und Guidelines**: Grundlegende Prinzipien und Richtlinien für die Entwicklung
+- **Framework-Module**: Dokumentation zu den einzelnen Framework-Komponenten
+- **Entwicklungsrichtlinien**: Detaillierte Anleitungen zu Performance, Testing und mehr
+- **Architektur**: Übersicht und Details zur Systemarchitektur
+- **KI-Assistent-Integration**: Anleitung zur Verwendung des KI-Assistenten
+
+## Für neue Entwickler
+
+Wenn Sie neu im Projekt sind, empfehlen wir Ihnen, mit folgenden Dokumenten zu beginnen:
+
+1. [Projektstruktur](/architecture/STRUKTUR-DOKUMENTATION.md) - Um einen Überblick zu bekommen
+2. [Coding-Guidelines](/standards/CODING-GUIDELINES.md) - Um die Coding-Standards zu verstehen
+3. [Modul-Checkliste](/framework/MODUL-CHECKLISTE.md) - Um die Modularisierung zu verstehen
+
+## Beitragen zur Dokumentation
+
+Die Dokumentation ist ein lebendiges Dokument. Wenn Sie Fehler finden oder Verbesserungen vorschlagen möchten, erstellen Sie bitte einen Pull Request mit Ihren Änderungen.
diff --git a/docs/standards/CODING-GUIDELINES.md b/docs/standards/CODING-GUIDELINES.md
new file mode 100644
index 00000000..ead459c7
--- /dev/null
+++ b/docs/standards/CODING-GUIDELINES.md
@@ -0,0 +1,234 @@
+# Coding Guidelines
+
+## Allgemeine Prinzipien
+
+Diese Guidelines definieren die Standards für die Entwicklung und Wartung des Projekts. Sie sorgen für Konsistenz, Lesbarkeit und Wartbarkeit des Codes.
+
+## PHP-Version
+
+- **PHP 8.4**: Die Codebase nutzt stets die neueste stabile PHP-Version (aktuell PHP 8.4)
+- Alle neuen PHP-Sprachfeatures sollten, wo sinnvoll, genutzt werden
+
+## Abhängigkeiten
+
+- **Externe Abhängigkeiten vermeiden**: Das Projekt soll möglichst ohne externe Bibliotheken auskommen
+- **Eigene Implementierungen bevorzugen**: Anstatt externe Pakete einzubinden, sollten eigene Lösungen entwickelt werden
+- **Erlaubte Abhängigkeiten**: Nur die bereits in composer.json definierten Pakete dürfen verwendet werden
+- **Neue Abhängigkeiten**: Müssen explizit genehmigt werden und sollten nur in Ausnahmefällen hinzugefügt werden
+
+## Klassenstruktur
+
+### Klassen
+
+- **Alle Klassen müssen `final` sein**, es sei denn, es gibt einen zwingenden Grund für Vererbung
+- **Keine abstrakten Klassen** - bevorzuge Interfaces und Kompositionen
+- **Klassen sollten `readonly` sein**, wann immer möglich
+- Interfaces verwenden, um Verträge zwischen Komponenten zu definieren
+
+```php
+// Gut
+final readonly class AnalyticsManager
+{
+    // ...
+}
+
+// Vermeiden
+abstract class BaseManager
+{
+    // ...
+}
+```
+
+### Properties
+
+- **Properties sollten `readonly` sein**, wann immer möglich
+- Private Visibility für alle Properties, es sei denn, es gibt einen zwingenden Grund
+- Typisierung ist obligatorisch für alle Properties
+
+```php
+// Gut
+private readonly StorageInterface $storage;
+
+// Vermeiden
+public array $config;
+```
+
+## Methoden und Funktionen
+
+- Typisierung ist obligatorisch für alle Parameter und Rückgabewerte
+- Methoden sollten klein und fokussiert sein (Single Responsibility)
+- Verwende named arguments für bessere Lesbarkeit
+
+```php
+// Gut
+public function track(string $event, array $properties = [], ?string $userId = null): void
+{
+    // ...
+}
+
+// Vermeiden
+public function process($data)
+{
+    // ...
+}
+```
+
+## Dependency Injection
+
+- Constructor Injection für alle Abhängigkeiten
+- Keine Service Locator oder globale Zustände
+- Verwende das `#[Initializer]`-Attribut für Service-Registrierung
+
+```php
+// Gut
+public function __construct(
+    private readonly Configuration $config,
+    private readonly StorageInterface $storage
+) {}
+
+// Vermeiden
+public function __construct()
+{
+    $this->config = Container::get(Configuration::class);
+}
+```
+
+## Moderne PHP-Features
+
+### Nullable Types und Union Types
+
+```php
+public function findUser(?int $id): ?User
+public function process(int|string $identifier): void
+```
+
+### Match Expression statt Switch
+
+```php
+// Gut
+return match($storageType) {
+    'file' => new FileStorage($path),
+    'redis' => new RedisStorage($connection),
+    default => throw new \InvalidArgumentException("Nicht unterstützter Storage-Typ: {$storageType}")
+};
+
+// Vermeiden
+switch ($storageType) {
+    case 'file':
+        return new FileStorage($path);
+    // ...
+}
+```
+
+### Named Arguments
+
+```php
+$this->createUser(
+    email: 'user@example.com',
+    role: 'admin',
+    sendWelcomeEmail: true
+);
+```
+
+### Constructor Property Promotion
+
+```php
+public function __construct(
+    private readonly Configuration $config,
+    private readonly PathProvider $pathProvider
+) {}
+```
+
+## Fehlerbehandlung
+
+- Spezifische Exceptions werfen
+- Typed Exceptions verwenden
+- Early Return Pattern bevorzugen
+
+```php
+// Gut
+if (!$this->isValid()) {
+    throw new ValidationException('Ungültige Daten');
+}
+
+// Vermeiden
+if ($this->isValid()) {
+    // Lange Verarbeitung...
+} else {
+    throw new Exception('Fehler');
+}
+```
+
+## Testing
+
+- Tests mit Pest-Framework schreiben
+- Für jede öffentliche Methode sollte mindestens ein Test existieren
+- Mocking nur für externe Abhängigkeiten verwenden
+
+```php
+test('track method records events correctly', function () {
+    $analytics = new Analytics($manager, $dispatcher);
+    $analytics->track('test_event', ['key' => 'value']);
+
+    expect($manager->getEvents())->toHaveCount(1);
+});
+```
+
+## Dokumentation
+
+- PHPDoc für alle öffentlichen Methoden und Klassen
+- Typen in PHPDoc sollten den tatsächlichen Typen entsprechen
+- Klare, beschreibende Kommentare für komplexe Logik
+
+```php
+/**
+ * Zeichnet ein Event auf und wendet Middleware an
+ *
+ * @param string $event Event-Name
+ * @param array $properties Event-Eigenschaften
+ * @param string|null $userId Benutzer-ID (optional)
+ */
+public function track(string $event, array $properties = [], ?string $userId = null): void
+```
+
+## Namenskonventionen
+
+- **Klassen**: PascalCase (`AnalyticsManager`)
+- **Methoden/Funktionen**: camelCase (`getEventStats()`)
+- **Variablen**: camelCase (`$eventData`)
+- **Konstanten**: SNAKE_CASE (`MAX_BATCH_SIZE`)
+- **Dateien**: Klassenname.php (`AnalyticsManager.php`)
+
+## Architektur
+
+- Dependency Inversion Principle befolgen
+- Interfaces für alle externen Abhängigkeiten
+- Vermeide zirkuläre Abhängigkeiten zwischen Modulen
+- Services sollten eine klare, fokussierte Verantwortung haben
+
+## Performance
+
+- Lazy Loading für ressourcenintensive Operationen
+- Caching wo sinnvoll
+- Datenstrukturen sorgfältig auswählen
+
+## Security
+
+- Alle Benutzereingaben validieren und bereinigen
+- Prepared Statements für Datenbankabfragen
+- Vermeidung von `eval()` und ähnlichen unsicheren Funktionen
+- Sensible Daten niemals in Logs schreiben
+
+## Best Practices
+
+- **Immutability**: Bevorzuge unveränderliche Objekte
+- **Pure Functions**: Bevorzuge reine Funktionen ohne Seiteneffekte
+- **Enums**: Verwende Enums statt String-Konstanten für feste Optionssätze
+- **DTOs**: Verwende Data Transfer Objects für Datentransport
+- **Value Objects**: Verwende Value Objects für semantisch reiche Datentypen
+
+## Refactoring
+
+- Code, der diese Guidelines nicht erfüllt, sollte beim Bearbeiten aktualisiert werden
+- Tests müssen vor und nach dem Refactoring bestehen
+- Große Refactorings sollten in kleinen, separaten Commits erfolgen
diff --git a/docs/standards/SICHERHEITS-GUIDELINES.md b/docs/standards/SICHERHEITS-GUIDELINES.md
new file mode 100644
index 00000000..e9f3378b
--- /dev/null
+++ b/docs/standards/SICHERHEITS-GUIDELINES.md
@@ -0,0 +1,187 @@
+# Sicherheitsrichtlinien
+
+## Übersicht
+
+Diese Richtlinien definieren Standards und Best Practices für sichere Softwareentwicklung im Projekt.
+
+## Grundprinzipien
+
+### 1. Defense in Depth
+
+- Mehrere Sicherheitsschichten implementieren
+- Nicht auf eine einzelne Sicherheitsmaßnahme vertrauen
+- Fail-Safe-Mechanismen einbauen
+
+### 2. Least Privilege
+
+- Minimale Berechtigungen für Funktionen und Benutzer
+- Ressourcenzugriff nur bei Bedarf gewähren
+- Temporäre Berechtigungen nach Gebrauch entziehen
+
+### 3. Input-Validierung
+
+- Alle Benutzereingaben validieren und bereinigen
+- Whitelist-Ansatz bevorzugen (erlaubte Eingaben definieren)
+- Typprüfung und Formatvalidierung durchführen
+
+```php
+// Beispiel: Sichere Input-Validierung
+public function processUserInput(string $input): string
+{
+    // Länge prüfen
+    if (strlen($input) > 100) {
+        throw new ValidationException('Input zu lang (max 100 Zeichen)');
+    }
+
+    // Inhalt validieren (Whitelist-Ansatz)
+    if (!preg_match('/^[a-zA-Z0-9\s\-_]+$/', $input)) {
+        throw new ValidationException('Input enthält ungültige Zeichen');
+    }
+
+    // Bereinigung
+    return htmlspecialchars($input, ENT_QUOTES, 'UTF-8');
+}
+```
+
+## Spezifische Sicherheitsmaßnahmen
+
+### 1. SQL-Injection-Prävention
+
+- Prepared Statements für alle Datenbankabfragen
+- Keine dynamischen SQL-Queries
+- ORM-Framework bevorzugen
+
+```php
+// Sicher
+$stmt = $pdo->prepare("SELECT * FROM users WHERE email = ?");
+$stmt->execute([$email]);
+
+// Unsicher - NIEMALS SO MACHEN
+$query = "SELECT * FROM users WHERE email = '{$email}'";
+```
+
+### 2. Cross-Site Scripting (XSS) Prävention
+
+- Output-Escaping für alle benutzergenerierten Inhalte
+- Content-Security-Policy (CSP) implementieren
+- HttpOnly und Secure Flags für Cookies
+
+```php
+// Ausgabe in HTML
+echo htmlspecialchars($userInput, ENT_QUOTES, 'UTF-8');
+
+// Ausgabe in JavaScript
+echo json_encode($userInput, JSON_HEX_TAG | JSON_HEX_APOS | JSON_HEX_QUOT | JSON_HEX_AMP);
+```
+
+### 3. Cross-Site Request Forgery (CSRF) Schutz
+
+- CSRF-Token für alle ändernden Anfragen
+- SameSite-Attribut für Cookies
+
+```php
+// CSRF-Token generieren
+public function generateCsrfToken(): string
+{
+    $token = bin2hex(random_bytes(32));
+    $_SESSION['csrf_token'] = $token;
+    return $token;
+}
+
+// CSRF-Token validieren
+public function validateCsrfToken(string $token): bool
+{
+    return hash_equals($_SESSION['csrf_token'] ?? '', $token);
+}
+```
+
+### 4. Sichere Authentifizierung
+
+- Passwörter mit starken Algorithmen hashen (Argon2id)
+- Multi-Faktor-Authentifizierung anbieten
+- Ratelimiting für Login-Versuche
+
+```php
+// Passwort hashen
+public function hashPassword(string $password): string
+{
+    return password_hash($password, PASSWORD_ARGON2ID);
+}
+
+// Passwort verifizieren
+public function verifyPassword(string $password, string $hash): bool
+{
+    return password_verify($password, $hash);
+}
+```
+
+### 5. Sichere Datenspeicherung
+
+- Sensible Daten verschlüsseln
+- Separate Schlüssel für unterschiedliche Daten
+- Schlüsselrotation implementieren
+
+```php
+// Daten verschlüsseln
+public function encrypt(string $data, string $purpose): string
+{
+    $key = $this->getEncryptionKey($purpose);
+    $nonce = random_bytes(SODIUM_CRYPTO_SECRETBOX_NONCEBYTES);
+
+    $cipher = sodium_crypto_secretbox(
+        $data,
+        $nonce,
+        $key
+    );
+
+    return base64_encode($nonce . $cipher);
+}
+
+// Daten entschlüsseln
+public function decrypt(string $encrypted, string $purpose): string
+{
+    $key = $this->getEncryptionKey($purpose);
+    $decoded = base64_decode($encrypted);
+
+    $nonce = mb_substr($decoded, 0, SODIUM_CRYPTO_SECRETBOX_NONCEBYTES, '8bit');
+    $cipher = mb_substr($decoded, SODIUM_CRYPTO_SECRETBOX_NONCEBYTES, null, '8bit');
+
+    return sodium_crypto_secretbox_open(
+        $cipher,
+        $nonce,
+        $key
+    );
+}
+```
+
+## Sicherheitstests
+
+### 1. Automatisierte Sicherheitstests
+
+- Static Application Security Testing (SAST)
+- Dynamic Application Security Testing (DAST)
+- Dependency-Scanning für bekannte Schwachstellen
+
+### 2. Penetrationstests
+
+- Regelmäßige Sicherheitsaudits
+- Manuelle Penetrationstests
+- Bug-Bounty-Programme
+
+## Sicherheitskultur
+
+### 1. Entwicklerschulungen
+
+- Regelmäßige Sicherheitsschulungen
+- Code-Reviews mit Sicherheitsfokus
+- Sicherheits-Champions im Team
+
+### 2. Incident Response
+
+- Sicherheitsvorfälle dokumentieren
+- Prozess für Sicherheitsmeldungen
+- Notfallpläne für Sicherheitsvorfälle
+
+## Zusammenfassung
+
+Sicherheit ist ein kontinuierlicher Prozess, keine einmalige Aufgabe. Diese Richtlinien sollten regelmäßig überprüft und aktualisiert werden, um neuen Bedrohungen zu begegnen.
diff --git a/docs/standards/index.md b/docs/standards/index.md
new file mode 100644
index 00000000..43a8c588
--- /dev/null
+++ b/docs/standards/index.md
@@ -0,0 +1,50 @@
+# Coding-Standards und Richtlinien
+
+## Übersicht
+
+Diese Standards und Richtlinien definieren die grundlegenden Prinzipien für die Codierung und Sicherheit im Projekt. Sie gewährleisten Konsistenz, Wartbarkeit und Sicherheit des Codes.
+
+## Verfügbare Standards
+
+- [Coding Guidelines](/standards/CODING-GUIDELINES.md) - Allgemeine Coding-Standards für das Projekt
+- [Sicherheitsrichtlinien](/standards/SICHERHEITS-GUIDELINES.md) - Standards für sichere Softwareentwicklung
+
+## Coding Guidelines
+
+Die [Coding Guidelines](/standards/CODING-GUIDELINES.md) definieren die technischen Standards für die Codeentwicklung, einschließlich:
+
+- Klassenstruktur und -design
+- Property- und Methodendefinitionen
+- Nutzung moderner PHP-Features
+- Fehlerbehandlung
+- Dokumentation
+- Namenskonventionen
+
+## Sicherheitsrichtlinien
+
+Die [Sicherheitsrichtlinien](/standards/SICHERHEITS-GUIDELINES.md) bieten umfassende Anleitungen zur sicheren Softwareentwicklung:
+
+- Input-Validierung
+- SQL-Injection-Prävention
+- XSS-Schutz
+- CSRF-Schutz
+- Sichere Authentifizierung
+- Sichere Datenspeicherung
+- Session-Management
+
+## Anwendung der Standards
+
+Alle Teammitglieder sind verpflichtet, diese Standards in ihrer Arbeit anzuwenden. Sie dienen als Grundlage für Code-Reviews und Qualitätssicherung.
+
+## Abweichungen von Standards
+
+In Ausnahmefällen können Abweichungen von diesen Standards erforderlich sein. Solche Abweichungen sollten:
+
+1. Dokumentiert werden
+2. Begründet werden
+3. Im Team besprochen werden
+4. Auf ein Minimum beschränkt werden
+
+## Aktualisierungen
+
+Diese Standards werden regelmäßig überprüft und aktualisiert, um sicherzustellen, dass sie den neuesten Best Practices und Technologien entsprechen.
diff --git a/etc/docker/daemon.json b/etc/docker/daemon.json
new file mode 100644
index 00000000..a330256b
--- /dev/null
+++ b/etc/docker/daemon.json
@@ -0,0 +1,18 @@
+{
+  "log-driver": "json-file",
+  "log-opts": {
+    "max-size": "100m",
+    "max-file": "3"
+  },
+  "storage-driver": "overlay2",
+  "live-restore": true,
+  "userland-proxy": false,
+  "experimental": false,
+  "metrics-addr": "0.0.0.0:9323",
+  "default-address-pools": [
+    {
+      "base": "172.17.0.0/16",
+      "size": 24
+    }
+  ]
+}
diff --git a/examples/StaticPageExample.php b/examples/StaticPageExample.php
new file mode 100644
index 00000000..339ef5c1
--- /dev/null
+++ b/examples/StaticPageExample.php
@@ -0,0 +1,63 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Examples;
+
+use App\Framework\Attributes\Route;
+use App\Framework\Attributes\StaticPage;
+use App\Framework\Router\Result\ViewResult;
+
+/**
+ * Beispiel-Controller für die Verwendung des StaticPage-Attributs
+ */
+class StaticPageExampleController
+{
+    /**
+     * Startseite - wird als statische Seite generiert
+     */
+    #[Route('/')]
+    #[StaticPage]
+    public function home(): ViewResult
+    {
+        return new ViewResult(template: 'home');
+    }
+
+    /**
+     * Über uns - wird als statische Seite generiert mit benutzerdefiniertem Pfad
+     */
+    #[Route('/about')]
+    #[StaticPage(outputPath: 'ueber-uns')]
+    public function about(): ViewResult
+    {
+        return new ViewResult(template: 'about');
+    }
+
+    /**
+     * Kontaktseite - wird als statische Seite generiert, aber nur wenn prerender=true
+     */
+    #[Route('/contact')]
+    #[StaticPage(prerender: true)]
+    public function contact(): ViewResult
+    {
+        return new ViewResult(template: 'contact');
+    }
+
+    /**
+     * Admin-Bereich - wird NICHT als statische Seite generiert, da kein StaticPage-Attribut
+     */
+    #[Route('/admin')]
+    public function admin(): ViewResult
+    {
+        return new ViewResult(template: 'admin');
+    }
+
+    /**
+     * Dynamische Seite - wird NICHT als statische Seite generiert, da prerender=false
+     */
+    #[Route('/dynamic')]
+    #[StaticPage(prerender: false)]
+    public function dynamic(): ViewResult
+    {
+        return new ViewResult(template: 'dynamic');
+    }
+}
diff --git a/examples/qr_code_example.php b/examples/qr_code_example.php
new file mode 100644
index 00000000..5b92a42d
--- /dev/null
+++ b/examples/qr_code_example.php
@@ -0,0 +1,33 @@
+<?php
+
+declare(strict_types=1);
+
+require_once __DIR__ . '/../vendor/autoload.php';
+
+use App\Application\Service\QrCodeService;
+use App\Domain\QrCode\ValueObject\ErrorCorrectionLevel;
+
+$qrCodeService = new QrCodeService();
+
+// Einfache Verwendung
+$svgContent = $qrCodeService->generateSvg('https://example.com');
+file_put_contents('qr_code.svg', $svgContent);
+echo "SVG-QR-Code erstellt: qr_code.svg\n";
+
+// Mit benutzerdefinierten Einstellungen
+$pngContent = $qrCodeService->generatePng(
+    'Hallo Welt!',
+    ErrorCorrectionLevel::H,
+    moduleSize: 6,
+    margin: 8
+);
+file_put_contents('qr_code.png', $pngContent);
+echo "PNG-QR-Code erstellt: qr_code.png\n";
+
+// Matrix direkt verwenden
+$matrix = $qrCodeService->generateQrCode('Benutzerdefinierter QR-Code', ErrorCorrectionLevel::L);
+echo "QR-Code Größe: " . $matrix->getSize() . "x" . $matrix->getSize() . "\n";
+
+// Ausgabe der Matrix als Text (für Debugging)
+echo "ASCII-QR-Code:\n";
+echo $qrCodeService->generateAscii('https://example.com');
diff --git a/migrations/2024_01_01_create_meta_entries_table.sql b/migrations/2024_01_01_create_meta_entries_table.sql
new file mode 100644
index 00000000..e388c86d
--- /dev/null
+++ b/migrations/2024_01_01_create_meta_entries_table.sql
@@ -0,0 +1,65 @@
+-- Migration für Meta-Entries Tabelle
+-- Führe diese SQL-Datei aus um die Tabelle zu erstellen
+
+CREATE TABLE IF NOT EXISTS meta_entries (
+    id INT PRIMARY KEY AUTO_INCREMENT,
+
+    -- Route-basierte Meta-Daten
+    route_pattern VARCHAR(255) NULL,
+
+    -- Entity-basierte Meta-Daten
+    entity_type VARCHAR(100) NULL,
+    entity_id INT NULL,
+
+    -- Meta-Daten Felder
+    title VARCHAR(255) NULL,
+    description TEXT NULL,
+    keywords TEXT NULL,
+
+    -- Open Graph
+    og_title VARCHAR(255) NULL,
+    og_description TEXT NULL,
+    og_image VARCHAR(500) NULL,
+    og_type VARCHAR(50) NULL,
+
+    -- Twitter
+    twitter_card VARCHAR(50) NULL,
+    twitter_site VARCHAR(100) NULL,
+
+    -- Andere
+    canonical VARCHAR(500) NULL,
+    custom_meta JSON NULL,
+
+    -- System-Felder
+    priority INT DEFAULT 0,
+    active BOOLEAN DEFAULT TRUE,
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
+
+    -- Indizes
+    INDEX idx_route_pattern (route_pattern),
+    INDEX idx_entity (entity_type, entity_id),
+    INDEX idx_active_priority (active, priority),
+
+    -- Unique Constraints
+    UNIQUE KEY unique_route_pattern (route_pattern),
+    UNIQUE KEY unique_entity (entity_type, entity_id),
+
+    -- Constraints
+    CONSTRAINT check_route_or_entity CHECK (
+        (route_pattern IS NOT NULL AND entity_type IS NULL AND entity_id IS NULL) OR
+        (route_pattern IS NULL AND entity_type IS NOT NULL AND entity_id IS NOT NULL)
+    )
+);
+
+-- Beispiel-Daten einfügen
+INSERT INTO meta_entries (route_pattern, title, description, og_title, og_type, priority, active) VALUES
+('/', 'Startseite - Meine Website', 'Willkommen auf meiner Website. Hier finden Sie alles über...', 'Startseite', 'website', 100, TRUE),
+('/blog', 'Blog - Meine Website', 'Alle Artikel und Neuigkeiten aus unserem Blog', 'Blog', 'website', 90, TRUE),
+('/blog/*', 'Blog: {title} - Meine Website', '{description}', '{title}', 'article', 80, TRUE),
+('/contact', 'Kontakt - Meine Website', 'Nehmen Sie Kontakt mit uns auf. Wir freuen uns auf Ihre Nachricht.', 'Kontakt', 'website', 70, TRUE);
+
+-- Template-Beispiele mit Platzhaltern
+INSERT INTO meta_entries (entity_type, entity_id, title, description, og_title, og_description, priority, active) VALUES
+('product', 1, '{product.name} - Jetzt kaufen | Mein Shop', '{product.name} für nur {product.price}€. {truncate:product.description}', '{product.name}', '{truncate:product.description}', 100, TRUE),
+('article', 1, '{article.title} | Mein Blog', '{truncate:article.content}', '{article.title}', '{truncate:article.content}', 100, TRUE);
diff --git a/package.json b/package.json
index a73ec020..2630d4f5 100644
--- a/package.json
+++ b/package.json
@@ -2,12 +2,14 @@
   "devDependencies": {
     "@types/jest": "^29.2.5",
     "jest": "^29.3.1",
-    "vite": "^6.3.5"
+    "vite": "^6.3.5",
+    "vite-plugin-pwa": "^1.0.0"
   },
   "scripts": {
     "test": "jest",
     "dev": "vite",
-    "build": "vite build",
-    "preview": "vite preview"
+    "build": "vite build && cp dist/sw.js public/sw.js && rm -rf public/assets && cp -R dist/assets public/ && cp dist/.vite/manifest.json public/.vite/",
+    "preview": "vite preview",
+    "deploy": "vite build && rm -rf public/assets && cp -R dist/assets public/ && cp dist/.vite/manifest.json public/.vite/"
   }
 }
diff --git a/public/assets/css-CKd28aW2.js b/public/assets/css-CKd28aW2.js
deleted file mode 100644
index 8b137891..00000000
--- a/public/assets/css-CKd28aW2.js
+++ /dev/null
@@ -1 +0,0 @@
-
diff --git a/public/assets/css-CLfz37Tz.css b/public/assets/css-CLfz37Tz.css
deleted file mode 100644
index 2e6f9e35..00000000
--- a/public/assets/css-CLfz37Tz.css
+++ /dev/null
@@ -1 +0,0 @@
-p{color:red}html{background:#00f}
diff --git a/public/assets/css/styles.css b/public/assets/css/styles.css
deleted file mode 100644
index 5d1fbafc..00000000
--- a/public/assets/css/styles.css
+++ /dev/null
@@ -1,12 +0,0 @@
-* {
-
-}
-
-
-footer > nav {
-    display: flex;
-}
-
-footer > nav > li {
-    flex-direction: row;
-}
diff --git a/public/assets/images/hero.jpg b/public/assets/images/hero.jpg
new file mode 100644
index 00000000..ca4466d3
Binary files /dev/null and b/public/assets/images/hero.jpg differ
diff --git a/ansible/group_vars/web.yml b/public/assets/images/hero_also_small.jpg
similarity index 100%
rename from ansible/group_vars/web.yml
rename to public/assets/images/hero_also_small.jpg
diff --git a/ansible/roles/nginx/files/docker-entrypoint.sh b/public/assets/images/hero_small.jpg
similarity index 100%
rename from ansible/roles/nginx/files/docker-entrypoint.sh
rename to public/assets/images/hero_small.jpg
diff --git a/public/assets/js-DjO_n7Y6.js b/public/assets/js-DjO_n7Y6.js
deleted file mode 100644
index 29481374..00000000
--- a/public/assets/js-DjO_n7Y6.js
+++ /dev/null
@@ -1 +0,0 @@
-import"./css-CKd28aW2.js";
diff --git a/public/build-container.php b/public/build-container.php
new file mode 100644
index 00000000..2916fccd
--- /dev/null
+++ b/public/build-container.php
@@ -0,0 +1,90 @@
+<?php
+// build-container.php
+
+require __DIR__ . '/../vendor/autoload.php';
+
+use App\Framework\DI\DefaultContainer;
+use App\Framework\DI\ContainerCompiler;
+
+// Container initialisieren
+$container = new DefaultContainer();
+
+// Hier wichtige Core-Klassen registrieren
+$container->bind(\App\Framework\Http\RequestFactory::class, \App\Framework\Http\RequestFactory::class);
+// Weitere Bindungen...
+
+// Liste der zu kompilierenden Services
+$services = [
+    \App\Framework\Core\Application::class,
+    \App\Framework\EventBus\DefaultEventBus::class,
+    \App\Framework\CommandBus\DefaultCommandBus::class,
+    \App\Framework\Router\HttpRouter::class,
+    \App\Framework\Http\RequestFactory::class,
+    // Weitere wichtige Services...
+];
+
+// Services aus Verzeichnissen automatisch erkennen
+$servicesFromDiscovery = discoverServicesFromDirectories([
+    __DIR__ . '/../src/Application',
+    __DIR__ . '/../src/Framework',
+]);
+$services = array_merge($services, $servicesFromDiscovery);
+
+// Container kompilieren
+$compiler = new ContainerCompiler();
+$compiler->compile(
+    $container,
+    $services,
+    __DIR__ . '/../cache/CompiledContainer.php'
+);
+
+echo "Container kompiliert!\n";
+
+// Hilfsfunktion zum Entdecken von Services
+function discoverServicesFromDirectories(array $directories): array
+{
+    $services = [];
+    foreach ($directories as $directory) {
+        $iterator = new RecursiveIteratorIterator(new RecursiveDirectoryIterator($directory));
+        foreach ($iterator as $file) {
+            if ($file->isFile() && $file->getExtension() === 'php') {
+                $className = getClassNameFromFile($file->getRealPath());
+                if ($className) {
+                    $services[] = $className;
+                }
+            }
+        }
+    }
+    return $services;
+}
+
+function getClassNameFromFile(string $file): ?string
+{
+    $content = file_get_contents($file);
+    $tokens = token_get_all($content);
+    $namespace = '';
+    $class = '';
+    $namespaceFound = false;
+    $classFound = false;
+
+    foreach ($tokens as $token) {
+        if (is_array($token)) {
+            if ($token[0] === T_NAMESPACE) {
+                $namespaceFound = true;
+            } elseif ($namespaceFound && $token[0] === T_STRING) {
+                $namespace .= $token[1];
+            } elseif ($namespaceFound && $token[0] === T_NS_SEPARATOR) {
+                $namespace .= '\\';
+            } elseif ($token[0] === T_CLASS) {
+                $classFound = true;
+            } elseif ($classFound && $token[0] === T_STRING) {
+                $class = $token[1];
+                break;
+            }
+        } elseif ($namespaceFound && $token === ';') {
+            $namespaceFound = false;
+        }
+    }
+
+    return $namespace && $class ? $namespace . '\\' . $class : null;
+}
diff --git a/public/chat.html b/public/chat.html
new file mode 100644
index 00000000..ac1d6f44
--- /dev/null
+++ b/public/chat.html
@@ -0,0 +1,29 @@
+<!DOCTYPE html>
+<html lang="de">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>WebSocket Chat Demo</title>
+    <link rel="stylesheet" href="/css/chat.css">
+</head>
+<body>
+    <h1>WebSocket Chat Demo</h1>
+
+    <div class="connection-status status-disconnected" id="status">
+        Nicht verbunden
+    </div>
+
+    <div class="chat-container">
+        <div class="chat-messages" id="chatMessages">
+            <div class="message system">Willkommen im Chat! Verbindung wird hergestellt...</div>
+        </div>
+
+        <div class="chat-input">
+            <input type="text" id="messageInput" placeholder="Nachricht eingeben..." disabled>
+            <button id="sendButton" disabled>Senden</button>
+        </div>
+    </div>
+
+    <script src="/js/chat.js"></script>
+</body>
+</html>
diff --git a/public/css/admin.css b/public/css/admin.css
new file mode 100644
index 00000000..bb68dd5d
--- /dev/null
+++ b/public/css/admin.css
@@ -0,0 +1,380 @@
+/* Admin Dashboard Styles */
+:root {
+    --primary-color: #4a6cf7;
+    --secondary-color: #0e2e50;
+    --success-color: #28a745;
+    --danger-color: #dc3545;
+    --warning-color: #ffc107;
+    --info-color: #17a2b8;
+    --light-color: #f8f9fa;
+    --dark-color: #343a40;
+    --border-color: #e5e7eb;
+    --background-color: #f9fafb;
+    --header-height: 64px;
+    --footer-height: 60px;
+    --sidebar-width: 250px;
+}
+
+* {
+    box-sizing: border-box;
+    margin: 0;
+    padding: 0;
+}
+
+body.admin-page {
+    font-family: 'Inter', -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, 'Open Sans', 'Helvetica Neue', sans-serif;
+    background-color: var(--background-color);
+    color: var(--dark-color);
+    line-height: 1.5;
+}
+
+.admin-header {
+    background-color: var(--secondary-color);
+    color: white;
+    padding: 1rem 2rem;
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    box-shadow: 0 2px 5px rgba(0, 0, 0, 0.1);
+}
+
+.admin-header h1 {
+    font-size: 1.5rem;
+    font-weight: 600;
+}
+
+.admin-nav {
+    background-color: white;
+    display: flex;
+    padding: 0 1rem;
+    border-bottom: 1px solid var(--border-color);
+    overflow-x: auto;
+}
+
+.admin-nav a {
+    padding: 1rem 1.25rem;
+    color: var(--dark-color);
+    text-decoration: none;
+    border-bottom: 2px solid transparent;
+    font-weight: 500;
+    white-space: nowrap;
+}
+
+.admin-nav a:hover {
+    color: var(--primary-color);
+    border-bottom-color: var(--primary-color);
+}
+
+.admin-nav a.active {
+    color: var(--primary-color);
+    border-bottom-color: var(--primary-color);
+    font-weight: 600;
+}
+
+.admin-content {
+    padding: 2rem;
+    max-width: 1600px;
+    margin: 0 auto;
+    min-height: calc(100vh - var(--header-height) - var(--footer-height) - 48px);
+}
+
+.admin-footer {
+    background-color: white;
+    text-align: center;
+    padding: 1rem;
+    border-top: 1px solid var(--border-color);
+    color: #666;
+    font-size: 0.875rem;
+}
+
+/* Dashboard Stats */
+.dashboard-stats {
+    display: grid;
+    grid-template-columns: repeat(auto-fill, minmax(250px, 1fr));
+    gap: 1.5rem;
+    margin-bottom: 2rem;
+}
+
+.stat-box {
+    background-color: white;
+    border-radius: 8px;
+    padding: 1.5rem;
+    box-shadow: 0 1px 3px rgba(0, 0, 0, 0.1);
+    border: 1px solid var(--border-color);
+}
+
+.stat-box h3 {
+    font-size: 0.875rem;
+    color: #6b7280;
+    margin-bottom: 0.5rem;
+    font-weight: 500;
+}
+
+.stat-value {
+    font-size: 1.25rem;
+    font-weight: 600;
+    color: var(--dark-color);
+}
+
+.status-connected {
+    color: var(--success-color);
+}
+
+/* Extensions List */
+.admin-section {
+    background-color: white;
+    border-radius: 8px;
+    padding: 1.5rem;
+    box-shadow: 0 1px 3px rgba(0, 0, 0, 0.1);
+    margin-bottom: 2rem;
+    border: 1px solid var(--border-color);
+}
+
+.admin-section h2 {
+    font-size: 1.25rem;
+    margin-bottom: 1rem;
+    color: var(--secondary-color);
+    font-weight: 600;
+}
+
+.extensions-list {
+    display: flex;
+    flex-wrap: wrap;
+    gap: 0.5rem;
+}
+
+.extension-badge {
+    background-color: #e9ecef;
+    padding: 0.25rem 0.75rem;
+    border-radius: 50px;
+    font-size: 0.875rem;
+    color: #495057;
+}
+
+/* Tables */
+.admin-table {
+    width: 100%;
+    border-collapse: collapse;
+    margin-bottom: 2rem;
+}
+
+.admin-table th,
+.admin-table td {
+    padding: 0.75rem 1rem;
+    text-align: left;
+    border-bottom: 1px solid var(--border-color);
+}
+
+.admin-table th {
+    background-color: #f8f9fa;
+    font-weight: 600;
+    color: #495057;
+}
+
+.admin-table tbody tr:hover {
+    background-color: #f8f9fa;
+}
+
+/* Search and Filters */
+.admin-tools {
+    margin-bottom: 1.5rem;
+    display: flex;
+    gap: 1rem;
+    align-items: center;
+    flex-wrap: wrap;
+}
+
+.search-input {
+    padding: 0.5rem 1rem;
+    border: 1px solid var(--border-color);
+    border-radius: 4px;
+    font-size: 0.875rem;
+    width: 300px;
+    max-width: 100%;
+}
+
+.services-count {
+    font-size: 0.875rem;
+    color: #6b7280;
+}
+
+/* Service List */
+.service-list {
+    display: grid;
+    grid-template-columns: repeat(auto-fill, minmax(300px, 1fr));
+    gap: 1rem;
+}
+
+.service-item {
+    background-color: white;
+    border-radius: 6px;
+    padding: 1rem;
+    border: 1px solid var(--border-color);
+    box-shadow: 0 1px 2px rgba(0, 0, 0, 0.05);
+}
+
+.service-name {
+    font-weight: 500;
+    margin-bottom: 0.5rem;
+    word-break: break-word;
+}
+
+.service-category {
+    display: flex;
+    gap: 0.5rem;
+    flex-wrap: wrap;
+}
+
+.category-badge {
+    background-color: var(--primary-color);
+    color: white;
+    padding: 0.1rem 0.5rem;
+    border-radius: 4px;
+    font-size: 0.75rem;
+}
+
+.subcategory-badge {
+    background-color: #e9ecef;
+    color: #495057;
+    padding: 0.1rem 0.5rem;
+    border-radius: 4px;
+    font-size: 0.75rem;
+}
+
+/* Filter Tags */
+.filter-tags {
+    display: flex;
+    flex-wrap: wrap;
+    gap: 0.5rem;
+}
+
+.filter-tag {
+    background-color: #e9ecef;
+    border: none;
+    padding: 0.25rem 0.75rem;
+    border-radius: 50px;
+    font-size: 0.875rem;
+    color: #495057;
+    cursor: pointer;
+}
+
+.filter-tag:hover {
+    background-color: #dee2e6;
+}
+
+.filter-tag.active {
+    background-color: var(--primary-color);
+    color: white;
+}
+
+/* Progress Bar */
+.progress-bar {
+    width: 100%;
+    height: 8px;
+    background-color: #e9ecef;
+    border-radius: 4px;
+    overflow: hidden;
+    margin-bottom: 0.25rem;
+}
+
+.progress {
+    height: 100%;
+    background-color: var(--primary-color);
+    border-radius: 4px;
+}
+
+.progress-value {
+    font-size: 0.875rem;
+    color: #6b7280;
+}
+
+/* File List */
+.file-list {
+    max-height: 400px;
+    overflow-y: auto;
+    border: 1px solid var(--border-color);
+    border-radius: 4px;
+}
+
+.file-item {
+    padding: 0.5rem 1rem;
+    border-bottom: 1px solid var(--border-color);
+    font-size: 0.875rem;
+    font-family: monospace;
+}
+
+.file-item:last-child {
+    border-bottom: none;
+}
+
+/* Key List */
+.key-list {
+    max-height: 400px;
+    overflow-y: auto;
+    border: 1px solid var(--border-color);
+    border-radius: 4px;
+}
+
+.key-item {
+    padding: 0.5rem 1rem;
+    border-bottom: 1px solid var(--border-color);
+    font-size: 0.875rem;
+    font-family: monospace;
+}
+
+.key-item:last-child {
+    border-bottom: none;
+}
+
+.empty-message {
+    padding: 2rem;
+    text-align: center;
+    color: #6b7280;
+}
+
+/* Error Message */
+.error-message {
+    background-color: #fff5f5;
+    border: 1px solid #fed7d7;
+    padding: 2rem;
+    text-align: center;
+    border-radius: 8px;
+    color: var(--danger-color);
+}
+
+.error-message h2 {
+    margin-bottom: 1rem;
+    color: var(--danger-color);
+}
+
+/* Buttons */
+.btn {
+    padding: 0.5rem 1rem;
+    background-color: var(--primary-color);
+    color: white;
+    border-radius: 4px;
+    text-decoration: none;
+    font-weight: 500;
+    font-size: 0.875rem;
+    border: none;
+    cursor: pointer;
+}
+
+.btn:hover {
+    background-color: #3a5ce5;
+}
+
+/* Responsive */
+@media (max-width: 768px) {
+    .dashboard-stats {
+        grid-template-columns: 1fr;
+    }
+
+    .admin-content {
+        padding: 1rem;
+    }
+
+    .service-list {
+        grid-template-columns: 1fr;
+    }
+}
diff --git a/public/css/chat.css b/public/css/chat.css
new file mode 100644
index 00000000..15b48289
--- /dev/null
+++ b/public/css/chat.css
@@ -0,0 +1,87 @@
+body {
+    font-family: Arial, sans-serif;
+    max-width: 800px;
+    margin: 0 auto;
+    padding: 20px;
+}
+
+.chat-container {
+    border: 1px solid #ccc;
+    border-radius: 8px;
+    overflow: hidden;
+    display: flex;
+    flex-direction: column;
+    height: 500px;
+}
+
+.chat-messages {
+    flex: 1;
+    overflow-y: auto;
+    padding: 15px;
+    background: #f9f9f9;
+}
+
+.message {
+    margin-bottom: 10px;
+    padding: 8px 12px;
+    border-radius: 18px;
+    max-width: 80%;
+    word-wrap: break-word;
+}
+
+.message.system {
+    background-color: #f0f0f0;
+    color: #666;
+    text-align: center;
+    margin-left: auto;
+    margin-right: auto;
+    font-style: italic;
+}
+
+.message.user {
+    background-color: #e3f2fd;
+    margin-right: auto;
+}
+
+.message.self {
+    background-color: #dcf8c6;
+    margin-left: auto;
+}
+
+.chat-input {
+    display: flex;
+    padding: 10px;
+    background: #fff;
+    border-top: 1px solid #eee;
+}
+
+#messageInput {
+    flex: 1;
+    padding: 8px 12px;
+    border: 1px solid #ddd;
+    border-radius: 20px;
+    margin-right: 10px;
+}
+
+button {
+    background-color: #4CAF50;
+    color: white;
+    border: none;
+    padding: 8px 16px;
+    border-radius: 20px;
+    cursor: pointer;
+}
+
+button:hover {
+    background-color: #45a049;
+}
+
+.connection-status {
+    text-align: center;
+    margin-bottom: 10px;
+    font-weight: bold;
+}
+
+.status-connecting { color: #f39c12; }
+.status-connected { color: #2ecc71; }
+.status-disconnected { color: #e74c3c; }
diff --git a/public/index.php b/public/index.php
index f30ff099..82c2360f 100644
--- a/public/index.php
+++ b/public/index.php
@@ -2,83 +2,40 @@
 
 declare(strict_types=1);
 
-use App\Framework\Core\Discovery;
-use App\Framework\Core\DynamicRoute;
-use App\Framework\Core\PhpObjectExporter;
-use App\Framework\Core\RouteCache;
-use App\Framework\Core\RouteMapper;
-use App\Framework\Core\StaticRoute;
-use App\Framework\ErrorHandling\ErrorHandler;
-use App\Framework\Http\HttpMethod;
-use App\Framework\Router\RouteCollection;
+use App\Framework\Performance\PerformanceMeter;
+use App\Framework\Core\AppBootstrapper;
 
 require __DIR__ . '/../vendor/autoload.php';
+require __DIR__ . '/../src/Framework/Debug/helpers.php';
 
 // Fehleranzeige für die Entwicklung aktivieren
-error_reporting(E_ALL);
 ini_set('display_errors', 1);
+ini_set('display_startup_errors', 1);
+error_reporting(E_ALL);
 
-$rfl = new ReflectionClass(Discovery::class);;
-$ghost = $rfl->newLazyGhost(function (Discovery $object) {
-    // Initialize object in-place
-    $object->__construct();
+register_shutdown_function(function() {
+    $error = error_get_last();
+    if ($error !== null) {
+        echo "SHUTDOWN ERROR: " . print_r($error, true);
+    }
 });
 
 
-/*$clientrequest = new \App\Framework\HttpClient\ClientRequest(HttpMethod::GET, 'https://jsonplaceholder.typicode.com/posts');
+$meter = new PerformanceMeter();
 
-$client = new \App\Framework\HttpClient\CurlHttpClient();
+// Konfiguration
+$config = [
+    'debug' => true,
+    'async_discovery' => true,
+    // weitere Konfigurationsoptionen...
+];
 
-var_dump($client->send($clientrequest));*/
+// Anwendung initialisieren und ausführen
+$basePath = dirname(__DIR__);
+$bootstrapper = new AppBootstrapper($basePath, $meter, $config);
+$app = $bootstrapper->bootstrapWeb();
 
-$emitter = new \App\Framework\Http\ResponseEmitter();
-ErrorHandler::register($emitter);
-
-#echo dirname(__DIR__) . '/cache/routes.cache.php';
-
-$discovery = new Discovery(new \App\Framework\Core\RouteMapper());
-
-$results = $discovery->discover(__DIR__ . '/../src/Application/');
-
-
-$rc = new \App\Framework\Core\RouteCompiler();
-
-$routes = $rc->compile($results[\App\Framework\Attributes\Route::class]);
-
-$cacheFile = dirname(__DIR__) . '/cache/routes.cache.php';
-
-$routeCache = new \App\Framework\Core\RouteCache($cacheFile);
-
-$routeCache->save($routes);
-
-$request = new \App\Framework\Http\HttpRequest(
-    method: \App\Framework\Http\HttpMethod::tryFrom($_SERVER['REQUEST_METHOD'] ?? 'GET'),
-    path:parse_url( $_SERVER['REQUEST_URI'] ?? '/', PHP_URL_PATH),
-);
-
-#var_dump("<pre>", $routeCache->load());
-
-$router = new \App\Framework\Router\HttpRouter(new RouteCollection($routeCache->load()));
-
-$match = $router->match($request->method->value, $request->path);
-
-
-$dispatcher = new \App\Framework\Router\RouteDispatcher();
-$return = $dispatcher->dispatch($match);
-
-$responder = new \App\Framework\Router\RouteResponder();
-$response = $responder->respond($return);
-
-$emitter = new \App\Framework\Http\ResponseEmitter();
-$emitter->emit($response);
-
-/*$redis = new Predis\Client([
-    'scheme' => 'tcp',
-    'host'   => 'redis', // Service-Name aus docker-compose
-    'port'   => 6379,
-]);
-
-$redis->set('hello', 'world');
-echo $redis->get('hello'); // Gibt: world aus*/
+// Anwendung ausführen
+$app->run();
 
 exit;
diff --git a/public/js/chat.js b/public/js/chat.js
new file mode 100644
index 00000000..ea997ccd
--- /dev/null
+++ b/public/js/chat.js
@@ -0,0 +1,116 @@
+document.addEventListener('DOMContentLoaded', function() {
+    const statusElement = document.getElementById('status');
+    const chatMessages = document.getElementById('chatMessages');
+    const messageInput = document.getElementById('messageInput');
+    const sendButton = document.getElementById('sendButton');
+
+    let socket;
+    let userId = 'user_' + Math.floor(Math.random() * 10000);
+
+    function connect() {
+        updateStatus('connecting', 'Verbindung wird hergestellt...');
+
+        // WebSocket-Verbindung herstellen
+        const protocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:';
+        const host = window.location.host;
+        socket = new WebSocket(`${protocol}//${host}/chat/websocket`);
+
+        socket.onopen = function() {
+            updateStatus('connected', 'Verbunden');
+            enableChat();
+        };
+
+        socket.onmessage = function(event) {
+            const message = JSON.parse(event.data);
+            handleMessage(message);
+        };
+
+        socket.onclose = function() {
+            updateStatus('disconnected', 'Verbindung getrennt');
+            disableChat();
+
+            // Nach 5 Sekunden erneut verbinden
+            setTimeout(connect, 5000);
+        };
+
+        socket.onerror = function(error) {
+            console.error('WebSocket Error:', error);
+            addMessage('system', 'Fehler bei der Verbindung.');
+        };
+    }
+
+    function updateStatus(state, text) {
+        statusElement.className = 'connection-status status-' + state;
+        statusElement.textContent = text;
+    }
+
+    function enableChat() {
+        messageInput.disabled = false;
+        sendButton.disabled = false;
+        messageInput.focus();
+    }
+
+    function disableChat() {
+        messageInput.disabled = true;
+        sendButton.disabled = true;
+    }
+
+    function handleMessage(message) {
+        switch(message.type) {
+            case 'system':
+                addMessage('system', message.message);
+                break;
+
+            case 'user_joined':
+            case 'user_left':
+                addMessage('system', message.message);
+                break;
+
+            case 'chat_message':
+                const isOwnMessage = message.user_id === userId;
+                addMessage(isOwnMessage ? 'self' : 'user', message.message);
+                break;
+
+            case 'error':
+                addMessage('system', 'Fehler: ' + message.error);
+                break;
+        }
+    }
+
+    function addMessage(type, text) {
+        const messageElement = document.createElement('div');
+        messageElement.className = 'message ' + type;
+        messageElement.textContent = text;
+
+        chatMessages.appendChild(messageElement);
+
+        // Automatisch nach unten scrollen
+        chatMessages.scrollTop = chatMessages.scrollHeight;
+    }
+
+    function sendMessage() {
+        const text = messageInput.value.trim();
+        if (!text || !socket || socket.readyState !== WebSocket.OPEN) return;
+
+        const message = {
+            type: 'chat_message',
+            message: text
+        };
+
+        socket.send(JSON.stringify(message));
+        messageInput.value = '';
+        messageInput.focus();
+    }
+
+    // Event-Listener
+    sendButton.addEventListener('click', sendMessage);
+
+    messageInput.addEventListener('keypress', function(e) {
+        if (e.key === 'Enter') {
+            sendMessage();
+        }
+    });
+
+    // Initialisierung
+    connect();
+});
diff --git a/public/offline.html b/public/offline.html
new file mode 100644
index 00000000..6e3468fd
--- /dev/null
+++ b/public/offline.html
@@ -0,0 +1,12 @@
+<!DOCTYPE html>
+<html lang="de">
+<head>
+    <meta charset="UTF-8">
+    <title>Offline</title>
+    <style>body { font-family: sans-serif; padding: 2rem; }</style>
+</head>
+<body>
+<h1>📴 Du bist offline</h1>
+<p>Diese Seite wurde aus dem Cache geladen.</p>
+</body>
+</html>
diff --git a/public/robots.txt b/public/robots.txt
new file mode 100644
index 00000000..5152ab98
--- /dev/null
+++ b/public/robots.txt
@@ -0,0 +1,3 @@
+User-agent: *
+Disallow:
+Sitemap: https://michaelschiemer.de/sitemap.xml
diff --git a/public/test.php b/public/test.php
new file mode 100644
index 00000000..63eb0215
--- /dev/null
+++ b/public/test.php
@@ -0,0 +1,5 @@
+<?php
+ini_set('display_errors',1);
+ini_set('display_startup_errors',1);
+error_reporting(E_ALL);
+echo 'DEBUG '.date('Y-m-d H:i:s');
diff --git a/qodana.yaml b/qodana.yaml
new file mode 100644
index 00000000..ffdefb8a
--- /dev/null
+++ b/qodana.yaml
@@ -0,0 +1,32 @@
+#-------------------------------------------------------------------------------#
+#               Qodana analysis is configured by qodana.yaml file               #
+#             https://www.jetbrains.com/help/qodana/qodana-yaml.html            #
+#-------------------------------------------------------------------------------#
+version: "1.0"
+
+#Specify inspection profile for code analysis
+profile:
+  name: qodana.starter
+
+#Enable inspections
+#include:
+#  - name: <SomeEnabledInspectionId>
+
+#Disable inspections
+#exclude:
+#  - name: <SomeDisabledInspectionId>
+#    paths:
+#      - <path/where/not/run/inspection>
+
+php:
+  version: 8.4 #(Applied in CI/CD pipeline)
+
+#Execute shell command before Qodana execution (Applied in CI/CD pipeline)
+#bootstrap: sh ./prepare-qodana.sh
+
+#Install IDE plugins before Qodana execution (Applied in CI/CD pipeline)
+#plugins:
+#  - id: <plugin.id> #(plugin id can be found at https://plugins.jetbrains.com)
+
+#Specify Qodana linter for analysis (Applied in CI/CD pipeline)
+linter: jetbrains/qodana-php:2025.2
diff --git a/resources/css/STRUCTURE.md b/resources/css/STRUCTURE.md
new file mode 100644
index 00000000..fde5d740
--- /dev/null
+++ b/resources/css/STRUCTURE.md
@@ -0,0 +1,42 @@
+# CSS-Framework Struktur
+
+## Layer-Hierarchie
+1. reset
+2. base
+3. layout
+4. components
+5. utilities
+6. overrides
+
+## Benennungskonventionen
+- Dateinamen: kebab-case
+- Klassen: BEM oder Utility-First? (optional notieren)
+
+
+css/
+├── styles.css                    # Haupt-Importdatei
+├── settings/
+│   ├── colors.css               # Farbdefinitionen
+│   ├── typography.css           # Schriftgrößen, Fonts
+│   ├── spacing.css              # Abstände (margin, padding)
+│   └── variables.css            # Dauer, Easing, Radius, Z-Index etc.
+├── base/
+│   ├── reset.css                # Reset/Normalize
+│   ├── global.css               # globale Stile für html, body, etc.
+│   └── typography.css           # h1, p, etc.
+├── components/
+│   ├── header.css
+│   ├── nav.css
+│   ├── footer.css
+│   └── buttons.css
+├── layout/
+│   ├── container.css            # .page-container, max-widths, etc.
+│   └── grid.css                 # evtl. eigenes Grid-System
+├── utilities/
+│   ├── animations.css           # .fade-in, .shake, usw.
+│   ├── helpers.css              # .skip-link, .hidden, .visually-hidden
+│   └── scroll.css               # scroll-behavior, scrollbar-style
+├── forms/
+│   └── inputs.css
+└── themes/
+    └── dark.css                 # Farbanpassungen für Dark-Mode (optional)
diff --git a/resources/css/base/focus.css b/resources/css/base/focus.css
new file mode 100644
index 00000000..be2c765a
--- /dev/null
+++ b/resources/css/base/focus.css
@@ -0,0 +1,31 @@
+:focus-visible {
+    --outline-size: max(2px, 0.1em);
+
+    outline:
+        var(--outline-width, var(--outline-size))
+        var(--outline-style, solid)
+        var(--outline-color, currentColor);
+
+    outline-offset: var(--outline-offset, var(--outline-size));
+
+    border-radius: 0.25em;
+}
+
+:where(:not(:active):focus-visible) {
+    outline-offset: 5px;
+}
+
+@media (prefers-reduced-motion: no-preference) {
+    :where(:focus-visible) {
+        transition: outline-offset .2s ease;
+    }
+    :where(:not(:active):focus-visible) {
+        transition-duration: .25s;
+    }
+}
+
+/* Scroll margin allowance below focused elements
+  to ensure they are clearly in view */
+:focus {
+    scroll-padding-block-end: 8vh;
+}
diff --git a/resources/css/base/global.css b/resources/css/base/global.css
new file mode 100644
index 00000000..af019f53
--- /dev/null
+++ b/resources/css/base/global.css
@@ -0,0 +1,147 @@
+:root {
+    --container-width: min(90vw, 2000px);
+    --content-padding: clamp(1rem, 4vw, 3rem);
+    --header-height: 80px;
+
+}
+
+html {
+    background-color: var(--bg);
+}
+
+body {
+    color: var(--text);
+    min-height: 100vh;
+
+    display: flex;
+    flex-direction: column;
+
+    --outline-color: var(--accent);
+}
+
+body>header {
+    background: rgba(0, 0, 0, 0.8);
+    backdrop-filter: blur(10px);
+    border-block-end: 1px solid var(--accent);
+
+    position: sticky;
+    top: 0;
+    z-index: 100;
+
+
+    height: var(--header-height);
+    display: flex;
+    align-items: center;
+
+    &>div{
+        width: var(--container-width);
+        margin: 0 auto;
+        padding: 0 var(--content-padding);
+        display: flex;
+        justify-content: space-between;
+        align-items: center;
+    }
+}
+
+body>main {
+    flex: 1;
+    padding-top: 2rem;
+}
+
+body>footer {
+    margin-top: auto;
+}
+
+main>section {
+    width: var(--container-width);
+    margin: 0 auto;
+    padding: 4rem var(--content-padding);
+}
+
+section>.grid {
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(300px, 1fr));
+    gap: 2rem;
+    margin: 0 auto;
+    /*margin-top: 3rem;*/
+}
+
+
+
+@media(prefers-reduced-motion: no-preference) {
+    html {
+        scroll-behavior: smooth;
+    }
+}
+
+
+/* somehow does not work! */
+@media(prefers-reduced-motion: no-preference) {
+    :has(:target) {
+        scroll-behavior: smooth;
+    }
+}
+
+a {
+    --selection-text-decoration: underline;
+    --link-color: var(--accent);
+
+    --_color: var(--link-color, rgba(255, 255, 255, 0.5));
+    --_underline-color: var(--underline-color, currentColor);
+    --_thickness: 2px;
+    --_offset: 0.05em;
+    --_hover-color: oklch(from var(--link-color) 80% c h);
+
+    color: var(--_color);
+
+    text-decoration-line: var(--selection-text-decoration);
+    text-decoration-color: var(--_underline-color);
+    text-decoration-thickness: var(--_thickness);
+    text-underline-offset: var(--_offset);
+
+    padding: max(0.25rem, 0.1em) 0;
+
+    display: inline-block;
+
+    @media (prefers-reduced-motion: no-preference) {
+        transition:
+            color 0.15s ease-in-out,
+            text-decoration 0.15s,
+            transform 0.1s ease-in-out;
+    }
+    @media (prefers-reduced-motion: reduce) {
+        transition: none;
+    }
+    @media (forced-colors: active) {
+        forced-color-adjust: none;
+        color: LinkText;
+        text-decoration-color: LinkText;
+    }
+
+    &:hover,
+    &:focus-visible {
+        --_color: var(--_hover-color);
+
+        --_underline-color: rgba(255, 255, 255, 0.5);
+
+        /*text-shadow: 2px 2px 4px rgba(0, 0, 0, 0.3);
+
+        transform: translateY(-1px);*/
+    }
+
+    &:active {
+        --_color: oklch(from var(--link-color) 75% c h);
+
+        /*transform: translateY(1px);*/
+    }
+}
+
+/* Inline Link */
+p > a {
+    text-decoration: underline;
+    border:none;
+
+    /*&::after {
+        content: ' ↗';
+    }*/
+}
diff --git a/resources/css/base/index.css b/resources/css/base/index.css
new file mode 100644
index 00000000..2a9e3597
--- /dev/null
+++ b/resources/css/base/index.css
@@ -0,0 +1,4 @@
+@import "focus.css";
+@import "global.css";
+@import "media.css";
+@import "typography.css";
diff --git a/resources/css/base/media.css b/resources/css/base/media.css
new file mode 100644
index 00000000..55441fc1
--- /dev/null
+++ b/resources/css/base/media.css
@@ -0,0 +1,5 @@
+:where(img, video) {
+    max-width: 100%;
+    height: auto;
+    display: block;
+}
diff --git a/resources/css/base/reset.css b/resources/css/base/reset.css
new file mode 100644
index 00000000..57942c27
--- /dev/null
+++ b/resources/css/base/reset.css
@@ -0,0 +1,34 @@
+/* alle Elemente inklusive Pseudoelemente mit border-box rechnen lassen */
+*, *::before, *::after {
+    box-sizing: border-box;
+}
+
+:where(html, body, h1, h2, h3, h4, h5, h6, p, blockquote, figure, dl, dd, ul, ol) {
+    margin: 0;
+    padding: 0;
+}
+
+:where(table) {
+    border-collapse: collapse;
+    border-spacing: 0;
+}
+
+:where(article, aside, footer, header, nav, section, main) {
+    display: block;
+}
+
+[popover] {
+    /* CSSWG Issue #10258 */
+    inset: auto;
+}
+
+/* @link: https://moderncss.dev/12-modern-css-one-line-upgrades/#scroll-margin-topbottom */
+:where([id]) {
+    scroll-margin-block-start: 2rem;
+}
+
+/* Vererbung für SVG-Icons */
+svg {
+    fill: currentColor;
+    stroke: none;
+}
diff --git a/resources/css/base/typography.css b/resources/css/base/typography.css
new file mode 100644
index 00000000..8f30bf1e
--- /dev/null
+++ b/resources/css/base/typography.css
@@ -0,0 +1,108 @@
+html {
+    font-size: 100%;
+
+    font-family: 'Roboto', sans-serif;
+
+    -webkit-text-size-adjust: 100%;
+}
+
+body {
+    line-height: 1.5;
+    font-size: clamp(1.125rem, 4cqi, 1.5rem);
+}
+
+section {
+    container-type: inline-size;
+}
+
+/* trims of empty pixels above and below fonts */
+:is(h1, h2, h3, h4, h5, h6, p, button) {
+    text-box: trim-both cap alphabetic;
+}
+
+p,
+li,
+h1,
+h2,
+h3,
+h4,
+h5,
+h6 {
+    overflow-wrap: break-word;
+    padding-block: 1.5rem;
+
+    hyphens: auto;
+}
+
+
+h1, h2, h3, h4, h5, h6 {
+    text-wrap: balance;
+}
+
+h1 {
+    font-size: clamp(2rem, 6cqi, 6rem);
+    font-weight: 700;
+
+    line-height: 1.125;
+
+    max-inline-size: 25ch;
+
+    text-transform: uppercase;
+}
+
+h2 {
+    text-transform: uppercase;
+
+    font-size: 3.5rem;
+    font-weight: 700;
+    line-height: 1.65;
+    max-inline-size: 30ch;
+}
+
+h3 {
+    font-size: 2rem;
+    --selection-bg-color: rgba(0, 0, 255, 0.3);
+    --selection-text-color: #d8cc48;
+}
+
+h4 {
+    font-size: clamp(3rem, 4vw + 0.5rem, 4rem);
+    font-weight: 700;
+
+    max-inline-size: 25ch;
+
+}
+
+h5 {
+    font-size: 1.75rem;
+
+}
+
+h6 {
+    font-size: clamp(2rem, 3vw + 0.5rem, 3rem);
+}
+
+
+p {
+    text-wrap: pretty;
+
+    line-height: 1.2;
+
+    font-weight: 500;
+    letter-spacing: -0.03em;
+
+    /* max 75ch */
+    max-inline-size: 65ch;
+}
+
+blockquote {
+    text-transform: uppercase;
+
+    &::before {
+        content: '\201C';
+    }
+
+    &::after {
+        content: '\201D';
+    }
+}
diff --git a/resources/css/components/buttons.css b/resources/css/components/buttons.css
new file mode 100644
index 00000000..515e9d17
--- /dev/null
+++ b/resources/css/components/buttons.css
@@ -0,0 +1,99 @@
+:where(button, input):where(:not(:active)):focus-visible {
+    outline-offset: 5px;
+}
+
+/* All buttons */
+:where(
+    button,
+    input[type="button"],
+    input[type="submit"],
+    input[type="reset"],
+    input[type="file"]
+),
+/* ::file-selector-button does not work inside of :where() */
+:where(input[type="file"])::file-selector-button {
+    --_color: var(--color, var(--accent));
+
+    background-color: var(--_color);
+    color: black;
+
+    border: 2px solid var(--_color);
+
+    font: inherit;
+    letter-spacing: inherit;
+    line-height: 1.5;
+
+    border-radius: 1rem;
+    padding: 0.5em;
+
+    font-weight: 700;
+
+    object-fit: contain;
+
+    /*display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    text-align: center;
+    gap: 1ch;*/
+
+    cursor: pointer;
+    transition: all 0.2s ease-out;
+
+    user-select: none;
+    touch-action: manipulation;
+    -webkit-tap-highlight-color: transparent;
+    -webkit-touch-callout: none;
+
+    &:is(:hover, :focus-visible) {
+        --_hoverColor: oklch(from var(--color, var(--accent)) 40% c h);
+        --_color: var(--hoverColor, var(--_hoverColor));
+    }
+
+    &.secondary {
+        --color: lightgreen;
+        /*--hoverColor: lawngreen;*/
+    }
+
+    &.outline {
+        background: transparent;
+        color: var(--_color);
+    }
+}
+
+/* on hover but not active */
+:where(
+    button,
+    input[type="button"],
+    input[type="submit"],
+    input[type="reset"]):where(:not(:active):hover
+) {
+
+}
+
+:where([type="reset"]) {
+    color: red;
+}
+
+:where([type="reset"]:focus-visible) {
+    outline-color: currentColor;
+}
+
+
+:where(button,
+input[type="button"],
+input[type="submit"],
+input[type="reset"]
+)[disabled] {
+
+    cursor: not-allowed;
+}
+
+:where(input[type="file"]) {
+    inline-size: 100%;
+    max-inline-size: max-content;
+}
+
+:where(input[type="button"]),
+:where(input[type="file"])::file-selector-button {
+    appearance: none;
+}
diff --git a/resources/css/components/card.css b/resources/css/components/card.css
new file mode 100644
index 00000000..4b9ea535
--- /dev/null
+++ b/resources/css/components/card.css
@@ -0,0 +1,202 @@
+.card {
+    --_bg: var(--card-bg, var(--bg-alt));
+    --_border: var(--card-border, var(--border));
+    --_accent: var(--card-accent, var(--accent));
+
+    background-color: var(--_bg);
+    border: 1px solid var(--_border);
+    border-radius: var(--radius-lg);
+    padding: var(--space-lg);
+    transition: all 0.2s ease;
+    container-type: inline-size;
+}
+
+.card:hover {
+    transform: translateY(-2px);
+    border-color: var(--_accent);
+}
+
+/* Strukturelle Elemente mit Selektoren */
+.card > header {
+    display: flex;
+    align-items: flex-start;
+    justify-content: space-between;
+    gap: var(--space-md);
+    margin-bottom: var(--space-md);
+}
+
+.card > main {
+    flex: 1;
+    margin-bottom: var(--space-md);
+}
+
+.card > footer {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    padding-top: var(--space-sm);
+    border-top: 1px solid var(--_border);
+}
+
+/* Typografie mit Selektoren */
+.card h1,
+.card h2,
+.card h3 {
+    margin: 0;
+    color: var(--_accent);
+}
+
+.card h3 {
+    font-size: 1.25rem;
+    font-weight: 600;
+}
+
+.card p {
+    margin: 0 0 var(--space-sm) 0;
+    color: var(--text);
+}
+
+.card small {
+    color: oklch(70% 0.01 var(--h-bg));
+}
+
+/* Button-Gruppen mit Selektoren */
+.card footer > div {
+    display: flex;
+    gap: var(--space-sm);
+}
+
+.card button {
+    padding: var(--space-sm) var(--space-md);
+    border-radius: var(--radius-md);
+    border: 1px solid var(--_accent);
+    background: transparent;
+    color: var(--_accent);
+    cursor: pointer;
+    transition: all 0.2s ease;
+}
+
+.card button:first-child {
+    background-color: var(--_accent);
+    color: var(--bg);
+}
+
+.card button:hover {
+    background-color: var(--_accent);
+    color: var(--bg);
+}
+
+
+/*
+        ======================
+        VARIANTEN MIT KLASSEN
+        ======================
+        */
+
+/* Status-Varianten */
+.card--success {
+    --card-bg: var(--success-subtle);
+    --card-border: var(--success-border);
+    --card-accent: var(--success);
+}
+
+.card--error {
+    --card-bg: var(--error-subtle);
+    --card-border: var(--error-border);
+    --card-accent: var(--error);
+}
+
+/* Größen-Varianten */
+.card--compact {
+    padding: var(--space-md);
+}
+
+.card--compact > * {
+    margin-bottom: var(--space-sm);
+}
+
+.card--spacious {
+    padding: calc(var(--space-lg) * 1.5);
+}
+
+/* Layout-Varianten */
+.card--horizontal {
+    display: flex;
+    align-items: center;
+}
+
+.card--horizontal > header,
+.card--horizontal > main {
+    margin-bottom: 0;
+    margin-right: var(--space-lg);
+}
+
+/* Media-Variante */
+.card--media img {
+    width: 100%;
+    height: 200px;
+    object-fit: cover;
+    border-radius: var(--radius-md);
+    margin-bottom: var(--space-md);
+}
+
+
+/*
+======================
+RESPONSIVE MIT CONTAINER QUERIES
+======================
+*/
+
+/* Automatische Anpassung basierend auf Card-Größe */
+@container (max-width: 300px) {
+    .card > header {
+        flex-direction: column;
+        align-items: flex-start;
+    }
+
+    .card > footer {
+        flex-direction: column;
+        gap: var(--space-sm);
+        align-items: flex-start;
+    }
+}
+
+/* Demo-Styles */
+.demo-grid {
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(280px, 1fr));
+    gap: var(--space-lg);
+    margin-top: var(--space-lg);
+}
+
+.demo-grid--wide {
+    grid-template-columns: repeat(auto-fit, minmax(400px, 1fr));
+}
+
+h1 {
+    /*text-align: center;*/
+    background: linear-gradient(45deg, var(--accent), var(--success));
+    -webkit-background-clip: text;
+    -webkit-text-fill-color: transparent;
+    background-clip: text;
+}
+
+.section {
+    margin: 3rem 0;
+}
+
+.section h2 {
+    color: var(--accent);
+    margin-bottom: var(--space-lg);
+}
+
+/* Badge mit semantischem Selector */
+.card [role="status"] {
+    padding: 0.25rem 0.5rem;
+    border-radius: var(--radius-md);
+    font-size: 0.75rem;
+    font-weight: 600;
+    text-transform: uppercase;
+    background-color: var(--_accent);
+    color: var(--bg);
+}
diff --git a/resources/css/components/footer.css b/resources/css/components/footer.css
new file mode 100644
index 00000000..8948b64a
--- /dev/null
+++ b/resources/css/components/footer.css
@@ -0,0 +1,36 @@
+footer {
+    text-align: center;
+    padding-block: 1.5rem;
+
+    a {
+        --link-color: var(--muted);
+        font-size: 1.25rem;
+        font-weight: 400;
+        font-family: 'Roboto', sans-serif;
+    }
+}
+
+footer > p {
+    display: block;
+    margin-inline: auto;
+
+    letter-spacing: -0.01em;
+    font-size: 1rem;
+    color: var(--muted);
+}
+
+.footer-nav {
+    display: flex;
+    justify-content: center;
+    gap: 2rem; /* Abstand zwischen Links */
+    list-style: none;
+    padding: 0;
+    margin: 0.5rem 0 0; /* leichter Abstand nach dem Text */
+}
+
+@media (max-width: 500px) {
+    .footer-nav {
+        flex-direction: column;
+        gap: 0.5rem;
+    }
+}
diff --git a/resources/css/components/header.css b/resources/css/components/header.css
new file mode 100644
index 00000000..e66bb2d5
--- /dev/null
+++ b/resources/css/components/header.css
@@ -0,0 +1,50 @@
+main > .header {
+    position: fixed;
+    width: 100%;
+    z-index: 4000;
+}
+
+main > .header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    padding: 3rem; /* Optional: Abstand innen */
+
+    padding-inline: clamp(1.5rem, 4vw + 1rem, 3rem);
+
+    user-select: none;
+
+    a {
+        text-decoration: none;
+        color: #eee;
+        font-size: 2rem;
+        font-weight: 700;
+        font-family: 'Roboto', sans-serif;
+
+        transition: all 0.2s ease-in;
+
+        &:hover {
+            color: #fff;
+            text-shadow: 2px 2px 4px rgba(0, 0, 0, 0.3);
+        }
+
+    }
+
+    button {
+        background-color: transparent;
+        border: none;
+        cursor: pointer;
+        padding: 0;
+        appearance: none;
+        font-size: 2rem;
+        font-weight: 700;
+
+        z-index: 9999;
+
+
+        &:hover {
+            color: #fff;
+            text-shadow: 2px 2px 4px rgba(0, 0, 0, 0.3);
+        }
+    }
+}
diff --git a/resources/css/components/nav.css b/resources/css/components/nav.css
new file mode 100644
index 00000000..bcdd34c2
--- /dev/null
+++ b/resources/css/components/nav.css
@@ -0,0 +1,3 @@
+:root{
+
+}
diff --git a/resources/css/components/sidebar.css b/resources/css/components/sidebar.css
new file mode 100644
index 00000000..c9f42f11
--- /dev/null
+++ b/resources/css/components/sidebar.css
@@ -0,0 +1,119 @@
+body:has(aside.show) {
+    overflow: hidden;
+    scrollbar-gutter: stable;
+}
+
+aside {
+    --sidebar-width: min(50ch, 100vw);
+
+    position: absolute;
+    z-index: 3000;
+
+    visibility: hidden;
+
+    background-color: #2c1c59;
+    color: #fff;
+    padding: 3rem;
+    border: none;
+
+    /*position: fixed;*/
+    /*position: sticky;*/
+    top: 0;
+    right: 0;
+    bottom: 0;
+    left: calc(100vw - var(--sidebar-width));
+    width: var(--sidebar-width);
+    height: 100vh;
+
+    transition: opacity 0.25s, translate 0.25s, overlay 0.25s allow-discrete, display 0.25s allow-discrete;
+
+    opacity: 0;
+    translate: 100% 0;
+
+    &.show {
+        visibility: visible;
+
+        opacity: 1;
+        translate: 0 0;
+    }
+
+    button {
+        place-content: end;
+        background-color: transparent;
+        border: none;
+        cursor: pointer;
+        padding: 0;
+        appearance: none;
+        font-size: 2rem;
+        font-weight: 700;
+
+        margin-inline-end: 0.5rem;
+        float: right;
+
+
+        &:hover {
+            color: #fff;
+            text-shadow: 2px 2px 4px rgba(0, 0, 0, 0.3);
+        }
+    }
+
+}
+
+/* Backdrop */
+.backdrop {
+    position: fixed;
+    inset: 0;
+    background: rgba(0, 0, 0, 0.5);
+    backdrop-filter: blur(4px);
+    opacity: 0;
+    pointer-events: none;
+    transition: opacity 0.3s ease;
+    z-index: 1000;
+
+    /*cursor: url(https://s3-us-west-2.amazonaws.com/s.cdpn.io/9632/heart.svg), auto;*/
+}
+:is(aside.show) .backdrop {
+    opacity: 1;
+}
+body:has(aside.show) .backdrop {
+    opacity: 1;
+    pointer-events: auto;
+}
+
+aside > nav > ul {
+
+    padding-block-start: 10rem;
+
+    display: flex;
+    flex-direction: column;
+
+    list-style: none;
+    gap: 3rem;
+
+    a {
+        text-decoration: none;
+        font-weight: 700;
+        text-transform: uppercase;
+        font-size: 1rem;
+        /*font-size: 1.5rem;*/
+    }
+
+    @media (hover) and (prefers-reduced-motion: no-preference) {
+        & > li {
+            transition: opacity .3s ease;
+        }
+
+        &:has(:hover) > li:not(:hover) {
+            opacity: .85;
+        }
+
+        /* for keyboard support */
+        &:is(:hover, :focus-within) > li:not(:hover, :focus-within) {
+            opacity: .85;
+        }
+    }
+}
+
+.backdrop:has( ~ #sidebar a:hover,  ~ #sidebar a:focus)/*, .backdrop:has( ~ #sidebar a:focus)*/ {
+    background-color: rgba(0 0 0 / 0.1);
+}
diff --git a/resources/css/forms/inputs.css b/resources/css/forms/inputs.css
new file mode 100644
index 00000000..32328fe4
--- /dev/null
+++ b/resources/css/forms/inputs.css
@@ -0,0 +1,101 @@
+:where(button, input, optgroup, select, textarea) {
+    font: inherit;
+}
+
+textarea, select, input {
+    field-sizing: content;
+}
+
+/* defensive style - just demo values */
+textarea {
+    min-block-size: 3lh;
+    max-block-size: 80svh;
+    min-inline-size: 30ch;
+    max-inline-size: 80ch;
+    resize: vertical;
+}
+
+form {
+    display: grid;
+    gap: 1rem;
+
+    padding: 1em;
+
+    background: radial-gradient(var(--bg), var(--bg-alt)) 50%;
+
+    border-radius: 0.5em;
+    border: 1px solid var(--muted);
+}
+
+
+:where(input) {
+    font-size: inherit;
+
+    inline-size: fit-content;
+
+    min-inline-size: 25ch;
+
+    padding: 0.5rem;
+
+    border-radius: 0.25rem;
+    border: none;
+
+    color: var(--text);
+
+    &::placeholder {
+        font-style: italic;
+    }
+
+    &:required {
+
+    }
+
+    &:not(:placeholder-shown, :focus):user-invalid {
+        background-color: #300a0a;
+        color: #ffc8c8;
+    }
+}
+
+label:has(input:required)::before {
+    content: "* ";
+}
+
+label:has(input) {
+    background-color: red;
+    display: inline-flex;
+    flex-direction: column;
+    inline-size: fit-content;
+}
+
+select,
+::picker(select) {
+    appearance: base-select;
+}
+
+select {
+    padding: 0.25em;
+    inline-size: fit-content;
+
+    &::marker {
+        color: red;
+    }
+}
+
+select::picker-icon {
+    color: #999;
+    transition: 0.4s rotate;
+}
+
+select:open::picker-icon {
+    rotate: 180deg;
+}
+
+
+/* select items */
+::picker(select) {
+    appearance: base-select;
+}
+
+option:checked {
+    font-weight: bold;
+}
diff --git a/resources/css/layout/container.css b/resources/css/layout/container.css
new file mode 100644
index 00000000..8178cf9f
--- /dev/null
+++ b/resources/css/layout/container.css
@@ -0,0 +1,15 @@
+.page-container {
+    /*display: flex;
+    flex: 1;
+    flex-direction: column;*/
+
+
+    padding-inline: 0; /* horizontale Abstände */
+    max-width: 100%;
+    margin-inline: auto; /* zentriert bei größerem Viewport */
+    width: 100%;
+}
+
+.page-content * {
+    padding-inline: 10rem; /* horizontale Abstände */
+}
diff --git a/resources/css/layout/grid.css b/resources/css/layout/grid.css
new file mode 100644
index 00000000..f81a31f0
--- /dev/null
+++ b/resources/css/layout/grid.css
@@ -0,0 +1,3 @@
+* {
+
+}
diff --git a/resources/css/settings/colors.css b/resources/css/settings/colors.css
new file mode 100644
index 00000000..aad13a11
--- /dev/null
+++ b/resources/css/settings/colors.css
@@ -0,0 +1,101 @@
+:root {
+    /* Hue-System */
+    --h-primary: 295;    /* Ihr Violett-Rosa */
+    --h-bg: 270;         /* Ihr Hintergrund-Violett */
+    --h-success: 145;    /* Grün */
+    --h-warning: 65;     /* Orange */
+    --h-error: 25;       /* Rot */
+    --h-info: 240;       /* Blau */
+
+    /* Einheitliche Lightness-Abstufungen */
+    --l-subtle: 25%;    /* Für dezente Hintergründe */
+    --l-hover: 50%;     /* Für Hover-States */
+    --l-border: 70%;    /* Für sichtbare Rahmen */
+    --l-text: 85%;      /* Für gut lesbaren Text */
+
+    /* Chroma-System basierend auf Anwendungsfall */
+    --c-vivid: 0.18;     /* Für Hauptfarben, Buttons */
+    --c-moderate: 0.12;  /* Für UI-Elemente */
+    --c-subtle: 0.06;    /* Für Hintergründe */
+    --c-muted: 0.03;     /* Für sehr dezente Effekte */
+
+    /**
+     * 🖤 Hintergrundfarben – kein HDR nötig
+     * L: Lightness, C: Chroma, H: Hue
+     */
+    --bg: oklch(18% 0.01 270);       /* sehr dunkles Violettblau */
+    --bg-alt: oklch(26% 0.015 270);  /* leicht aufgehellt */
+
+    /**
+     * 🤍 Textfarben – hoher Kontrast
+     */
+    --text: oklch(95% 0.005 270);    /* fast weiß */
+    --muted: oklch(70% 0.01 270);    /* leichtes Grau mit Farbstich */
+
+    /**
+     * 🎨 Akzentfarbe – sichtbar, auch auf HDR
+     * oklch ist bevorzugt, da linear; P3 gibt extra Boost bei HDR-Displays
+     */
+    --accent: oklch(70% 0.2 295); /* sattes Violett-Rosa */
+    --accent-p3: color(display-p3 1 0.3 0.8); /* pink/lila – intensiver auf HDR */
+
+    /** Border */
+    --border: oklch(40% 0.02 var(--h-bg));
+
+    /**
+     * ✨ Glow-Farbe – über 100% L (= HDR-like)
+     */
+    --glow: oklch(115% 0.22 295); /* extrem helles pink, über weiß hinaus */
+
+
+    /**
+     * Semantische Farbpalette
+     */
+    --success-base: oklch(60% var(--c-vivid) var(--h-success));
+    --success: var(--success-base);
+    --success-subtle: oklch(var(--l-subtle) var(--c-muted) var(--h-success));
+    --success-hover: oklch(var(--l-hover) var(--c-vivid) var(--h-success));
+    --success-border: oklch(var(--l-border) var(--c-moderate) var(--h-success));
+    --success-text: oklch(var(--l-text) var(--c-subtle) var(--h-success));
+
+    --error-base: oklch(55% 0.18 25);
+
+
+
+
+    --warning-base: oklch(70% 0.12 65);
+
+    --info-base: oklch(60% 0.15 240);
+
+
+
+    /* Manuelle Varianten für bessere Browser-Unterstützung */
+
+    --error: var(--error-base);
+    --error-subtle: oklch(var(--l-subtle) 0.036 25);
+    --error-hover: oklch(var(--l-hover) 0.18 25);
+    --error-border: oklch(var(--l-border) 0.14 25);
+    --error-text: oklch(var(--l-text) 0.12 25);
+
+    --warning: var(--warning-base);
+    --warning-subtle: oklch(25% 0.024 65);
+    --warning-border: oklch(80% 0.096 65);
+
+    /**
+     * 🎯 Fallback für alte Browser: überschreiben P3 mit oklch automatisch
+     */
+    color-scheme: dark;
+
+    background-color: var(--bg);
+    color: var(--text);
+}
+
+/**
+ * 🖥️ HDR-Support – bei Geräten mit Dynamic Range Support (aktuell v. a. Safari)
+ */
+/* noinspection CssInvalidMediaFeature */
+@media (dynamic-range: high) {
+    :root {
+        --accent: var(--accent-p3);
+    }
+}
diff --git a/resources/css/settings/variables.css b/resources/css/settings/variables.css
new file mode 100644
index 00000000..9172fa35
--- /dev/null
+++ b/resources/css/settings/variables.css
@@ -0,0 +1,9 @@
+* {
+    --color-primary: #412785;
+
+    --space-sm: 0.5rem;
+    --space-md: 1rem;
+    --space-lg: 1.5rem;
+    --radius-md: 0.5rem;
+    --radius-lg: 1rem;
+}
diff --git a/resources/css/styles.css b/resources/css/styles.css
index 20b20fbd..9b492feb 100644
--- a/resources/css/styles.css
+++ b/resources/css/styles.css
@@ -1,7 +1,266 @@
-p {
-    color: red;
+@layer reset, base, layout, components, utilities, overrides;
+
+@import url('settings/colors.css') layer(settings);
+@import url('settings/variables.css') layer(settings);
+@import url('base/reset.css') layer(reset);
+@import url('base') layer(base);
+@import url('layout/container.css') layer(layout);
+@import url('components/header.css') layer(components);
+@import url('components/footer.css') layer(components);
+@import url('components/sidebar.css') layer(components);
+@import url('components/nav.css') layer(components);
+@import url('components/buttons.css') layer(components);
+@import url('components/card.css') layer(components);
+@import url('forms/inputs.css') layer(components);
+@import url('utilities/helpers.css') layer(utilities);
+@import url('utilities/animations.css') layer(utilities);
+@import url('utilities/noise.css') layer(utilities);
+@import url('utilities/scroll.css') layer(utilities);
+
+@layer overrides {
+    /* Benutzerdefinierte Styles */
+}
+
+:root {
+    overscroll-behavior: none;
+
+    accent-color: #412785;
+
+    /* thumb = brighter brand-color */
+    scrollbar-color: #5d37bc rgba(0 0 0 / 0); /* thumb + track */
+
+
+    color-scheme: dark light;
+
+    --duration-default: 0.2s;
+    --duration-medium: 0.35s;
+    --duration-slow: 0.5s;
+
+    --easing-default: cubic-bezier(0.22, 0.61, 0.36, 1);
+    --easing-bounce: linear(0 0%, 0 0.27%, 0.02 4,53%);
+}
+
+::selection {
+    --_selection-bg-color: var(--selection-bg-color, #ff4081);
+    --_selection-text-color: var(--selection-text-color, #fff);
+
+
+    background-color: var(--_selection-bg-color); /* Pink */
+    color: var(--_selection-text-color);
+
+    text-shadow: 0 0 0.25rem var(--_selection-text-color);
+
+    text-decoration: var(--selection-text-decoration, none);
+}
+
+::-webkit-scrollbar {
+    /*width: 0.5rem;*/
+}
+
+
+
+@media(prefers-reduced-motion: no-preference) {
+    :focus {
+        transition: outline-offset .25s ease;
+    }
+    :focus:not(:active) {
+        outline-offset: 5px;
+    }
 }
 
 html {
-    background: blue;
+    /* evtl per Mediaquery auf thin umschalten */
+    scrollbar-width: auto;
+    /*scrollbar-color: #412785 #412785;*/
+
+    /* @link: https://moderncss.dev/12-modern-css-one-line-upgrades/#scrollbar-gutter */
+    scrollbar-gutter: stable /*both-edges*/;
+}
+
+body {
+    display: flex;
+    flex-direction: column;
+
+    overflow-x: clip;
+    overscroll-behavior: contain;
+
+    /* move body back in 3d:
+    border-radius: 10px;
+    overflow: hidden;
+    scale: 95%;
+    background-color: #2c1;
+
+    * {
+        visibility: hidden;
+    }
+    */
+}
+
+
+picture {
+    user-select: none;
+}
+
+/*section,
+.page-container > * {
+    padding-inline: clamp(2.5rem, 20%, 10rem);
+}*/
+
+section.hero {
+    display: flex;
+    min-height: 100vh;
+    /*height: 100%;
+    width: 100%;*/
+    /*background-color: #412785;*/
+    background-color: var(--bg);
+    color: var(--accent);
+    padding-block-start: 10rem;
+
+    /*background-image: url("https://localhost/assets/images/hero_small.jpg");
+    background-size: cover;
+    background-position: center;*/
+
+    :where(:not(picture, img, h1)) {
+        position: relative;
+    }
+
+    flex-direction: column;
+    gap: 2ch;
+}
+
+.hero picture, .hero img {
+    position: absolute;
+    inset: 0;
+    width: 100%;
+    height: 100%;
+    object-fit: cover;
+    z-index: 0;
+}
+
+/* Lazy loading? */
+section {
+    content-visibility: auto;
+}
+
+
+
+h1 {
+    user-select: none;
+    padding-block-end: 3.33rem; /* front-size / 3 */
+    /*text-align: center;*/
+
+
+    text-shadow: 0 0 4px rgba(0, 0, 0, 0.1);
+
+    background: linear-gradient(
+        90deg,
+        oklch(70% 0.25 280),
+        oklch(80% 0.3 340),
+        oklch(70% 0.25 280)
+    );
+    background-size: 200% auto;
+
+    /* Für Firefox */
+    -webkit-background-clip: text;
+    -webkit-text-fill-color: transparent;
+
+    background-clip: text;
+    color: transparent;
+
+    animation: shimmer 10s linear infinite;
+
+    /*animation: shimmer 4s alternate-reverse infinite;*/
+}
+
+
+
+/*@keyframes shimmer {
+    0% { opacity: 0.5; }
+    100% { opacity: 1; }
+}*/
+
+@keyframes shimmer {
+    0% { background-position: 0 center; }
+    100% { background-position: -200% center; }
+}
+
+::backdrop {
+    background-color: #412785;
+    /*opacity: 0.7;*/
+    background-color: rgba(0, 0, 0, 0.2);
+
+    filter: blur(5px);
+    backdrop-filter: blur(5px);
+}
+
+
+
+@starting-style {
+    #mypopover {
+        &:popover-open {
+            opacity: 0;
+            translate: 100% 0;
+        }
+    }
+}
+
+html:has(aside.show) {
+    /*scrollbar-width: none;*/
+}
+
+.fade-in-on-scroll {
+    opacity: 0;
+    transform: translateY(100px);
+    transition: opacity 0.6s ease, transform 0.6s ease;
+    will-change: opacity, transform;
+}
+
+.fade-in-on-scroll.visible {
+    opacity: 1;
+    transform: translateY(0);
+}
+
+
+/*body::before {
+    content: '';
+    position: fixed;
+    top: 50%;
+    left: 0;
+    right: 0;
+    height: 2px;
+    background: red;
+    pointer-events: none;
+    z-index: 9999;
+}*/
+
+[aria-current="page"] {}
+
+form>div {
+    display: flex;
+    flex-direction: column;
+    gap: 1rem;
+
+    border: 1px solid var(--muted);
+
+    &:has(input:user-invalid:not(:placeholder-shown, :focus)) {
+        [role="alert"] {
+            visibility: visible;
+        }
+    }
+}
+
+[role="alert"] {
+    visibility: hidden;
+    min-height: 2rem;
+    font-size: 1rem;
+
+    background-color: red;
+    border: darkred 2px solid;
+    border-radius: 0.5em;
+    padding: 0.25em;
+    color: black;
+}
+
+span[id^="hint"] {
+    color: var(--muted);
 }
diff --git a/resources/css/utilities/animations.css b/resources/css/utilities/animations.css
new file mode 100644
index 00000000..c8e86f56
--- /dev/null
+++ b/resources/css/utilities/animations.css
@@ -0,0 +1,38 @@
+.fade {
+    opacity: 0;
+    transform: translateY(40px);
+    transition: opacity 0.6s ease, transform 0.6s ease;
+}
+
+.fade.entered {
+    color: #0af;
+}
+
+.fade-in    { transition: opacity 0.4s ease-out; }
+.fade-out   { transition: opacity 0.4s ease-in; }
+.zoom-in    { transition: transform 0.5s ease-out; }
+
+/* Beispielanimation */
+@keyframes shake {
+    0%, 100% { transform: translateX(0); }
+    25%      { transform: translateX(-5px); }
+    75%      { transform: translateX(5px); }
+}
+.shake {
+    animation: shake 0.8s ease-in-out;
+}
+
+
+
+.fade-in-on-scroll,
+.zoom-in {
+    opacity: 0;
+    transform: translateY(40px);
+    transition: opacity 0.6s ease, transform 0.6s ease;
+    will-change: opacity, transform;
+}
+
+.visible {
+    opacity: 1;
+    transform: none;
+}
diff --git a/resources/css/utilities/helpers.css b/resources/css/utilities/helpers.css
new file mode 100644
index 00000000..f4cea3e9
--- /dev/null
+++ b/resources/css/utilities/helpers.css
@@ -0,0 +1,18 @@
+/* Set some base styles, so it is easy to see */
+.skip-link {
+    position: absolute;
+    display: inline-block;
+    padding: .375rem .75rem;
+    line-height: 1;
+    font-size: 1.25rem;
+    background-color: rebeccapurple;
+    color: white;
+    /* Ensure the Y position is set to zero and any movement on the transform property */
+    transform: translateY(0);
+    transition: transform 250ms ease-in;
+}
+
+/* When it is not focused, transform its Y position by its total height, using a negative value, so it hides above the viewport */
+.skip-link:not(:focus) {
+    transform: translateY(-2rem);
+}
diff --git a/resources/css/utilities/noise.css b/resources/css/utilities/noise.css
new file mode 100644
index 00000000..1fe56fa6
--- /dev/null
+++ b/resources/css/utilities/noise.css
@@ -0,0 +1,62 @@
+.noise-bg {
+    --noise-opacity: 0.15;
+
+    background-image:
+        repeating-radial-gradient(circle at 1px 1px,
+        rgba(255, 255, 255, var(--noise-opacity, 0.03)) 0,
+        rgba(0, 0, 0, var(--noise-opacity, 0.03)) 1px,
+        transparent 2px
+        );
+    background-size: 3px 3px;
+}
+
+.grain {
+    position: fixed;
+    inset: 0;
+    pointer-events: none;
+    z-index: 9999;
+
+    background-color: #000;
+    mix-blend-mode: overlay;
+    opacity: 0.5;
+
+    animation: noise 1s steps(10) infinite;
+}
+
+@keyframes noise {
+    0%  { filter: hue-rotate(0deg); }
+    100% { filter: hue-rotate(360deg); }
+}
+
+.noise-overlay {
+    --noise-intensity: 0.03;
+
+    view-transition-name: noise;
+
+
+    position: fixed;
+    inset: 0;
+    z-index: 9999;
+    pointer-events: none;
+
+    mix-blend-mode: overlay;
+
+    background-size: cover;
+    background: url("data:image/svg+xml;utf8,\
+<svg xmlns='http://www.w3.org/2000/svg' width='100%' height='100%'>\
+<filter id='noiseFilter'>\
+<feTurbulence type='fractalNoise' baseFrequency='0.8' numOctaves='4' stitchTiles='stitch'/>\
+</filter>\
+<rect width='100%' height='100%' filter='url(%23noiseFilter)'/>\
+</svg>") repeat, rgba(0, 0, 0, var(--noise-intensity, 0.03));
+}
+
+.noise-overlay {
+    opacity: var(--noise-opacity, 0.05);
+    transition: opacity 0.3s ease;
+    pointer-events: none;
+}
+
+.noise-overlay.hidden {
+    opacity: 0;
+}
diff --git a/resources/css/utilities/scroll.css b/resources/css/utilities/scroll.css
new file mode 100644
index 00000000..23d4335f
--- /dev/null
+++ b/resources/css/utilities/scroll.css
@@ -0,0 +1,200 @@
+body {
+    transition: background-color 0.5s ease, color 0.5s ease;
+}
+
+/* FOR REFERENCE::
+
+body[data-active-scroll-step="1"] header {
+    opacity: 1;
+}
+
+body[data-active-scroll-step="2"] header {
+    opacity: 0.5;
+}
+
+body[data-active-scroll-step="3"] header {
+    transform: translateY(-100%);
+    transition: transform 0.3s ease;
+}*/
+
+body[data-active-scroll-step="1"] {
+    background-color: #1a1a1a;
+    color: #eee;
+}
+
+body[data-active-scroll-step="2"] {
+    background-color: #000;
+    color: #f0f0f0;
+}
+
+body[data-active-scroll-step="3"] {
+    background-color: #2c1c59;
+    color: #fff;
+}
+
+body[data-active-scroll-step="1"] {
+    /* z.B. Schriftart, Hintergrund etc. */
+    cursor: s-resize;
+}
+
+body[data-active-scroll-step="2"] {
+    background-color: #1a1a1a;
+}
+
+[data-scroll-step] {
+    opacity: 0;
+    transform: translateY(2rem);
+    transition: opacity 0.6s ease, transform 0.6s ease;
+    will-change: opacity, transform;
+}
+
+body {
+    opacity: 1;
+}
+
+/* Aktivierte Scroll-Section */
+[data-scroll-step].active {
+    opacity: 1;
+    transform: translateY(0);
+}
+
+
+[data-scroll-step].active {
+    border-left: 4px solid var(--accent-color, #6c4dff);
+    background-color: rgba(255, 255, 255, 0.02);
+}
+
+
+
+/* Basis-Stil für Sticky Steps */
+[data-sticky-step] {
+    position: sticky;
+    top: 20vh;
+    margin: 2rem 0;
+    padding: 2rem;
+    background: #1e1e1e;
+    border-radius: 0.5rem;
+    opacity: 0.4;
+    transition: opacity 0.3s ease, transform 0.3s ease;
+}
+
+[data-sticky-step].is-sticky-active {
+    opacity: 1;
+    transform: scale(1.02);
+    box-shadow: 0 0 1rem rgba(255, 255, 255, 0.05);
+}
+
+/* Beispielhafte visuelle Steuerung per container-Datensatz */
+[data-sticky-container][data-active-sticky-step="0"] [data-sticky-step]:nth-child(1),
+[data-sticky-container][data-active-sticky-step="1"] [data-sticky-step]:nth-child(2),
+[data-sticky-container][data-active-sticky-step="2"] [data-sticky-step]:nth-child(3) {
+    border-left: 4px solid var(--accent-color, #6c4dff);
+    background: linear-gradient(to right, rgba(108, 77, 255, 0.1), transparent);
+}
+
+/* Optional: sanfte Farbübergänge */
+[data-sticky-step] {
+    transition: opacity 0.3s ease, transform 0.3s ease, background 0.4s ease;
+}
+
+/* Sticky Container zur Sicherheit sichtbar machen */
+[data-sticky-container] {
+    position: relative;
+    z-index: 0;
+
+    height: 300vh;
+    padding: 2rem;
+}
+
+
+/*
+    Scroll LOOPS
+*/
+
+.loop-container {
+    overflow: hidden;
+    position: relative;
+    height: 200px;
+}
+
+.loop-content {
+    display: flex;
+    flex-direction: column;
+}
+
+/* Basisstil für scroll-loop-Elemente */
+[data-scroll-loop] {
+    will-change: transform;
+    display: inline-block;
+    backface-visibility: hidden;
+    transform-style: preserve-3d;
+}
+
+/* Empfohlene Containerstruktur */
+.scroll-loop-container {
+    overflow: hidden;
+    position: relative;
+    height: 200px; /* anpassen je nach Bedarf */
+}
+
+/* Optional für automatische Verdopplung */
+.scroll-loop-container > [data-scroll-loop] {
+    display: flex;
+    flex-direction: column;
+}
+
+/* Für Background-Loop */
+[data-scroll-type="background"] {
+    background-repeat: repeat;
+    background-size: auto 100%;
+}
+
+/* Pausieren bei Hover oder Aktivierung */
+[data-scroll-loop][data-loop-pause="true"]:hover,
+[data-scroll-loop][data-loop-pause="true"]:active {
+    animation-play-state: paused;
+}
+
+
+/*
+    SCROLL_FADE
+ */
+
+/* Optionaler Grundstil für sticky-fade Elemente */
+/* Basisstil für sticky-fade Elemente */
+[data-sticky-fade] {
+    opacity: 0;
+    transform: translateY(20px);
+    transition-property: opacity, transform;
+    transition-duration: 0.4s;
+    transition-timing-function: ease-out;
+    will-change: opacity, transform;
+    pointer-events: auto;
+}
+
+[data-sticky-fade][data-fade-distance="10"] {
+    transform: translateY(10px);
+}
+[data-sticky-fade][data-fade-distance="30"] {
+    transform: translateY(30px);
+}
+[data-sticky-fade][data-fade-distance="40"] {
+    transform: translateY(40px);
+}
+
+[data-sticky-fade][data-fade-duration="fast"] {
+    transition-duration: 0.2s;
+}
+
+[data-sticky-fade][data-fade-duration="slow"] {
+    transition-duration: 0.8s;
+}
+
+[data-sticky-fade].visible {
+    opacity: 1;
+    transform: translateY(0);
+    box-shadow: 0 1rem 2rem rgba(0, 0, 0, 0.1);
+    filter: brightness(1.05);
+    transition-property: opacity, transform, box-shadow;
+    transition-timing-function: ease;
+}
diff --git a/resources/css/utilities/transitions.css b/resources/css/utilities/transitions.css
new file mode 100644
index 00000000..e3b78d65
--- /dev/null
+++ b/resources/css/utilities/transitions.css
@@ -0,0 +1,45 @@
+@view-transition {
+    navigation: auto;
+}
+
+@keyframes fade {
+    from { opacity: 0; }
+    to   { opacity: 1; }
+}
+
+@keyframes slide-down {
+    from { transform: translateY(-2rem); opacity: 0; }
+    to   { transform: translateY(0); opacity: 1; }
+}
+
+@keyframes slide-up {
+    from { transform: translateY(2rem); opacity: 0; }
+    to   { transform: translateY(0); opacity: 1; }
+}
+
+@keyframes blur-in {
+    from { filter: blur(10px); opacity: 0; }
+    to   { filter: blur(0); opacity: 1; }
+}
+
+/* 🎯 Transitions für benannte Bereiche */
+
+::view-transition-old(main-content),
+::view-transition-new(main-content) {
+    animation: fade 0.4s ease;
+}
+
+::view-transition-old(site-header),
+::view-transition-new(site-header) {
+    animation: slide-down 0.4s ease;
+}
+
+::view-transition-old(site-footer),
+::view-transition-new(site-footer) {
+    animation: slide-up 0.4s ease;
+}
+
+::view-transition-old(sidebar),
+::view-transition-new(sidebar) {
+    animation: blur-in 0.3s ease;
+}
diff --git a/resources/js/core/ClickManager.js b/resources/js/core/ClickManager.js
new file mode 100644
index 00000000..70308573
--- /dev/null
+++ b/resources/js/core/ClickManager.js
@@ -0,0 +1,136 @@
+// modules/core/click-manager.js
+import { Logger } from './logger.js';
+import { useEvent } from './useEvent.js';
+import {navigateTo} from "./navigateTo";
+import {SimpleCache} from "../utils/cache";
+
+let callback = null;
+let unsubscribes = [];
+let cleanupInterval = null;
+const prefetchCache = new SimpleCache(20, 60000); //new Map();
+const maxCacheSize = 20; // max. Anzahl gecachter Seiten
+const cacheTTL = 60000;  // Lebensdauer in ms (60s)
+
+function isInternal(link) {
+    return link.origin === location.origin;
+}
+
+function handleClick(e) {
+    const link = e.target.closest('a');
+    if (!link || e.defaultPrevented) return;
+
+    const href = link.getAttribute('href');
+    if (!href || href.startsWith('#')) return;
+
+    // Skip conditions
+    if (
+        link.target === '_blank' ||
+        link.hasAttribute('download') ||
+        link.getAttribute('rel')?.includes('external') ||
+        link.hasAttribute('data-skip')
+    ) {
+        Logger.info(`[click-manager] skipped: ${href}`);
+        return;
+    }
+
+    if (isInternal(link)) {
+        e.preventDefault();
+
+        const cached = prefetchCache.get(href);
+        const valid = cached && Date.now() - cached.timestamp < cacheTTL;
+
+        const options = {
+            viewTransition: link.hasAttribute('data-view-transition'),
+            replace: link.hasAttribute('data-replace'),
+            modal: link.hasAttribute('data-modal'),
+            prefetched: valid,
+            data: valid ? cached.data : null,
+        };
+
+        Logger.info(`[click-manager] internal: ${href}`, options);
+
+        if(options.modal) {
+            callback?.(href, link, options);
+        } else {
+            navigateTo(href, options);
+        }
+    }
+}
+
+let prefetchTimeout;
+function handleMouseOver(e) {
+    clearTimeout(prefetchTimeout);
+    const link = e.target.closest('a[href]');
+    if (!link || !isInternal(link)) return;
+
+    const href = link.getAttribute('href');
+    if (!href || prefetchCache.has(href)) return;
+
+    // optional: Wait 150ms to reduce noise
+    prefetchTimeout = setTimeout(() => prefetch(href), 150);
+}
+
+function prefetch(href) {
+    Logger.info(`[click-manager] prefetching: ${href}`);
+
+    fetch(href)
+        .then(res => res.text())
+        .then(html => {
+            if (prefetchCache.cache.size >= maxCacheSize) {
+                const oldestKey = [...prefetchCache.cache.entries()].sort((a, b) => a[1].timestamp - b[1].timestamp)[0][0];
+                prefetchCache.cache.delete(oldestKey);
+            }
+            prefetchCache.set(href, {
+                data: html,
+                timestamp: Date.now(),
+            });
+        })
+        .catch(err => {
+            Logger.warn(`[click-manager] prefetch failed for ${href}`, err);
+        });
+}
+
+function handlePopState() {
+    const href = location.pathname;
+    Logger.info(`[click-manager] popstate: ${href}`);
+    navigateTo(href, { replace: true });
+}
+
+export function getPrefetched(href) {
+    const cached = prefetchCache.get(href);
+    const valid = cached && Date.now() - cached.timestamp < cacheTTL;
+    return valid ? cached.data : null;
+}
+
+export function prefetchHref(href) {
+    if (!href || prefetchCache.has(href)) return;
+    prefetch(href);
+}
+
+export function init(onNavigate) {
+    callback = onNavigate;
+    unsubscribes = [
+        useEvent(document, 'click', handleClick),
+        useEvent(document, 'mouseover', handleMouseOver),
+        useEvent(window, 'popstate', handlePopState),
+    ]
+
+    cleanupInterval = setInterval(() => {
+        for (const [key, val] of prefetchCache.cache.entries()) {
+            if (Date.now() - val.timestamp > prefetchCache.ttl) {
+                prefetchCache.cache.delete(key);
+            }
+        }
+    }, 120000);
+
+
+    Logger.info('[click-manager] ready');
+}
+
+export function destroy() {
+    callback = null;
+    prefetchCache.clear();
+    unsubscribes.forEach(unsub => unsub());
+    unsubscribes = [];
+    Logger.info('[click-manager] destroyed');
+}
diff --git a/resources/js/core/EventManager.js b/resources/js/core/EventManager.js
new file mode 100644
index 00000000..1325df84
--- /dev/null
+++ b/resources/js/core/EventManager.js
@@ -0,0 +1,49 @@
+// modules/core/EventManager.js
+const registry = new Map();
+
+export const EventManager = {
+    /**
+     * Fügt einen EventListener hinzu und speichert ihn im Modul-Kontext
+     */
+    add(target, type, handler, { module = 'global', options = false } = {}) {
+        target.addEventListener(type, handler, options);
+        if (!registry.has(module)) registry.set(module, []);
+        registry.get(module).push([target, type, handler, options]);
+    },
+
+    /**
+     * Entfernt alle Listener, die für ein bestimmtes Modul registriert wurden
+     */
+    removeModule(module) {
+        const entries = registry.get(module);
+        if (!entries) return;
+
+        entries.forEach(([target, type, handler, options]) => {
+            target.removeEventListener(type, handler, options);
+        });
+
+        registry.delete(module);
+    },
+
+    /**
+     * Entfernt alle Event-Listener aus allen Modulen
+     */
+    clearAll() {
+        for (const [module, entries] of registry.entries()) {
+            entries.forEach(([target, type, handler, options]) => {
+                target.removeEventListener(type, handler, options);
+            });
+        }
+        registry.clear();
+    },
+
+    /**
+     * Debug: Gibt die aktuelle Registry in der Konsole aus
+     */
+    debug() {
+        console.table([...registry.entries()].map(([module, events]) => ({
+            module,
+            listeners: events.length
+        })));
+    }
+};
diff --git a/resources/js/core/PerformanceMonitor.js b/resources/js/core/PerformanceMonitor.js
new file mode 100644
index 00000000..de55a3c0
--- /dev/null
+++ b/resources/js/core/PerformanceMonitor.js
@@ -0,0 +1,73 @@
+// modules/core/PerformanceMonitor.js
+export class PerformanceMonitor {
+    constructor({ fps = true } = {}) {
+        this.fpsEnabled = fps;
+        this.fps = 0;
+        this.frameCount = 0;
+        this.lastTime = performance.now();
+        this.visible = false;
+        this.taskTimings = new Map();
+        this.logs = [];
+
+        this.container = document.createElement('div');
+        this.container.style.position = 'fixed';
+        this.container.style.bottom = '0';
+        this.container.style.left = '0';
+        this.container.style.font = '12px Consolas, monospace';
+        this.container.style.color = '#0f0';
+        this.container.style.background = 'rgba(0,0,0,0.75)';
+        this.container.style.padding = '0.5rem';
+        this.container.style.zIndex = '9999';
+        this.container.style.pointerEvents = 'none';
+        this.container.style.lineHeight = '1.4';
+        this.container.style.whiteSpace = 'pre';
+        this.container.style.display = 'none';
+
+        document.body.appendChild(this.container);
+
+        window.addEventListener('keydown', (e) => {
+            if (e.key === '§') {
+                this.visible = !this.visible;
+                this.container.style.display = this.visible ? 'block' : 'none';
+            }
+        });
+    }
+
+    log(message) {
+        const timestamp = new Date().toLocaleTimeString();
+        this.logs.push(`[${timestamp}] ${message}`);
+        if (this.logs.length > 5) this.logs.shift();
+    }
+
+    update(taskMap = new Map()) {
+        this.frameCount++;
+        const now = performance.now();
+        if (now - this.lastTime >= 1000) {
+            this.fps = this.frameCount;
+            this.frameCount = 0;
+            this.lastTime = now;
+
+            const timings = [];
+            for (const [id, duration] of this.taskTimings.entries()) {
+                timings.push(`${id}: ${duration.toFixed(2)}ms`);
+            }
+
+            const barWidth = Math.min(this.fps * 2, 100);
+            const logOutput = this.logs.slice().reverse().join('\n');
+
+            this.container.innerHTML = `
+FPS: ${this.fps} | Tasks: ${taskMap.size}
+${timings.join('\n')}
+<div style="width:${barWidth}%;height:4px;background:#0f0;margin-top:4px;"></div>
+${logOutput ? '\nLogs:\n' + logOutput : ''}
+      `;
+        }
+    }
+
+    trackTask(id, callback) {
+        const start = performance.now();
+        callback();
+        const duration = performance.now() - start;
+        this.taskTimings.set(id, duration);
+    }
+}
diff --git a/resources/js/core/events.js b/resources/js/core/events.js
new file mode 100644
index 00000000..97bf1e2f
--- /dev/null
+++ b/resources/js/core/events.js
@@ -0,0 +1,46 @@
+// src/core/events.js
+
+// --- 1. Globaler EventBus ---
+
+const listeners = new Map();
+
+/**
+ * Abonniert ein benanntes Event
+ */
+export function on(eventName, callback) {
+    if (!listeners.has(eventName)) listeners.set(eventName, []);
+    listeners.get(eventName).push(callback);
+
+    // Unsubscribe
+    return () => {
+        const arr = listeners.get(eventName);
+        if (arr) listeners.set(eventName, arr.filter(fn => fn !== callback));
+    };
+}
+
+/**
+ * Sendet ein benanntes Event mit Payload
+ */
+export function emit(eventName, payload) {
+    const arr = listeners.get(eventName);
+    if (arr) arr.forEach(fn => fn(payload));
+}
+
+// --- 2. ActionDispatcher ---
+
+const actionListeners = new Set();
+
+/**
+ * Action registrieren (globaler Listener für alle Aktionen)
+ */
+export function registerActionListener(callback) {
+    actionListeners.add(callback);
+    return () => actionListeners.delete(callback);
+}
+
+/**
+ * Aktion ausführen
+ */
+export function dispatchAction(type, payload = {}) {
+    actionListeners.forEach(fn => fn({ type, payload }));
+}
diff --git a/resources/js/core/frameloop.js b/resources/js/core/frameloop.js
new file mode 100644
index 00000000..10ee1b28
--- /dev/null
+++ b/resources/js/core/frameloop.js
@@ -0,0 +1,83 @@
+// modules/core/frameloop.js
+import {Logger} from "./logger";
+
+const tasks = new Map();
+let running = false;
+let showDebug = false;
+
+let lastTime = performance.now();
+let frameCount = 0;
+let fps = 0;
+
+
+const debugOverlay = document.createElement('div');
+debugOverlay.style.position = 'fixed';
+debugOverlay.style.bottom = '0';
+debugOverlay.style.left = '0';
+debugOverlay.style.font = '12px monospace';
+debugOverlay.style.color = '#0f0';
+debugOverlay.style.background = 'rgba(0,0,0,0.75)';
+debugOverlay.style.padding = '0.25rem 0.5rem';
+debugOverlay.style.zIndex = '9999';
+debugOverlay.style.pointerEvents = 'none';
+debugOverlay.style.display = 'none';
+const barWidth = Math.min(fps * 2, 100);
+const bar = `<div style="width:${barWidth}%;height:4px;background:#0f0;margin-top:4px;"></div>`;
+debugOverlay.innerHTML += bar;
+debugOverlay.style.lineHeight = '1.4';
+document.body.appendChild(debugOverlay);
+
+import { PerformanceMonitor } from './PerformanceMonitor.js';
+export const monitor = new PerformanceMonitor();
+
+window.addEventListener('keydown', (e) => {
+    if (e.key === '§') {
+        showDebug = !showDebug;
+        debugOverlay.style.display = showDebug ? 'block' : 'none';
+    }
+});
+
+export function registerFrameTask(id, callback, options = {}) {
+    tasks.set(id, callback);
+    if (options.autoStart && !running) startFrameLoop();
+}
+
+export function unregisterFrameTask(id) {
+    tasks.delete(id);
+}
+
+export function clearFrameTasks() {
+    tasks.clear();
+}
+
+export function startFrameLoop() {
+    if (running) return;
+    running = true;
+
+    function loop() {
+        for (const [id, task] of tasks) {
+            try {
+                if (showDebug) {
+                    monitor.trackTask(id, task);
+                } else {
+                    task();
+                }
+            } catch (err) {
+                Logger.warn(`[Frameloop] Fehler in Task:`, err);
+            }
+        }
+
+        if (showDebug) {
+            monitor.update(tasks);
+        }
+
+        requestAnimationFrame(loop);
+    }
+
+    requestAnimationFrame(loop);
+}
+
+export function stopFrameLoop() {
+    running = false;
+    // Achtung: Loop läuft weiter, solange nicht aktiv gestoppt
+}
diff --git a/resources/js/core/index.js b/resources/js/core/index.js
new file mode 100644
index 00000000..5f8c489c
--- /dev/null
+++ b/resources/js/core/index.js
@@ -0,0 +1,2 @@
+export * from './logger.js';
+export * from './useEvent';
diff --git a/resources/js/core/init.js b/resources/js/core/init.js
new file mode 100644
index 00000000..3f0c62a6
--- /dev/null
+++ b/resources/js/core/init.js
@@ -0,0 +1,125 @@
+/*
+const menu = document.getElementById("sidebar-menu");
+const closeBtn = menu.querySelector(".close-btn");
+
+closeBtn.addEventListener("click", () => {
+    menu.hidePopover();
+});
+*/
+
+
+import {registerModules} from "../modules";
+
+import {useEvent} from "./useEvent";
+
+
+
+/*import { createTrigger, destroyTrigger, destroyAllTriggers } from './scrollfx/index.js';
+
+createTrigger({
+    element: 'section',
+    target: '.fade',
+    start: 'top 80%',
+    end: 'bottom 30%',
+    scrub: true,
+    onUpdate: (() => {
+        const progressMap = new WeakMap();
+
+        return (el, progress) => {
+            if (!el) return;
+
+            let current = progressMap.get(el) || 0;
+            current += (progress - current) * 0.1;
+            progressMap.set(el, current);
+
+            el.style.opacity = current;
+            el.style.transform = `translateY(${30 - 30 * current}px)`;
+        };
+    })(),
+
+    onEnter: el => el.classList.add('entered'),
+    onLeave: el => {
+        el.classList.remove('entered');
+        el.style.opacity = 0;
+        el.style.transform = 'translateY(30px)';
+    }
+});*/
+
+
+
+
+
+/*
+let lastScrollY = window.scrollY;
+
+const fadeElements = document.querySelectorAll('.fade-in-on-scroll');
+
+// Observer 1: Einblenden beim Runterscrollen
+const fadeInObserver = new IntersectionObserver((entries) => {
+    const scrollingDown = window.scrollY > lastScrollY;
+    lastScrollY = window.scrollY;
+
+    entries.forEach(entry => {
+        if (entry.isIntersecting && scrollingDown) {
+            entry.target.classList.add('visible');
+        }
+    });
+}, {
+    threshold: 0.4,
+    rootMargin: '0px 0px -10% 0px'
+});
+
+// Observer 2: Ausblenden beim Hochscrollen
+const fadeOutObserver = new IntersectionObserver((entries) => {
+    const scrollingUp = window.scrollY < lastScrollY;
+    lastScrollY = window.scrollY;
+
+    entries.forEach(entry => {
+        if (!entry.isIntersecting && scrollingUp) {
+            entry.target.classList.remove('visible');
+        }
+    });
+}, {
+    threshold: 0.5,
+    rootMargin: '0% 0px 50% 0px' // früher triggern beim Hochscrollen
+});
+
+// Alle Elemente mit beiden Observern beobachten
+fadeElements.forEach(el => {
+    fadeInObserver.observe(el);
+    fadeOutObserver.observe(el);
+});
+*/
+
+
+/*
+const newContent = '<h1>Neue Seite</h1>'; // dein AJAX-Inhalt z. B.
+const container = document.querySelector('main');
+
+document.startViewTransition(() => {
+    container.innerHTML = newContent;
+});*/
+
+import { fadeScrollTrigger, zoomScrollTrigger, fixedZoomScrollTrigger } from '../modules/scrollfx/Tween.js';
+import {autoLoadResponsiveVideos} from "../utils/autoLoadResponsiveVideo";
+
+
+export async function initApp() {
+
+    await registerModules();
+
+    autoLoadResponsiveVideos();
+
+    /*initNoiseToggle({
+        selector: '.noise-overlay',
+        toggleKey: 'g',            // Taste zum Umschalten
+        className: 'grainy',       // Klasse auf <body>
+        enableTransition: true     // Smooth fade
+    });
+
+
+    fadeScrollTrigger('.fade');
+    zoomScrollTrigger('.zoomed');
+
+    fixedZoomScrollTrigger('h1');*/
+}
diff --git a/resources/js/core/logger-next.js b/resources/js/core/logger-next.js
new file mode 100644
index 00000000..9a55d239
--- /dev/null
+++ b/resources/js/core/logger-next.js
@@ -0,0 +1,277 @@
+/**
+ * Erweiterter Logger mit Processor-Architektur, Request-ID-Unterstützung und Server-Kommunikation.
+ */
+export class Logger {
+    /**
+     * Konfiguration des Loggers
+     */
+    static config = {
+        enabled: true,
+        apiEndpoint: '/api/log',
+        consoleEnabled: true,
+        serverEnabled: true,
+        minLevel: 'debug',
+    };
+
+    /**
+     * Liste der registrierten Processors
+     */
+    static processors = [];
+
+    /**
+     * Registrierte Handler
+     */
+    static handlers = [];
+
+    /**
+     * Aktive RequestID
+     */
+    static requestId = null;
+
+    /**
+     * Logger initialisieren
+     */
+    static initialize(config = {}) {
+        // Konfiguration überschreiben
+        this.config = { ...this.config, ...config };
+
+        // Standard-Processors registrieren
+        this.registerProcessor(this.requestIdProcessor);
+        this.registerProcessor(this.timestampProcessor);
+
+        // Standard-Handler registrieren
+        if (this.config.consoleEnabled) {
+            this.registerHandler(this.consoleHandler);
+        }
+
+        if (this.config.serverEnabled) {
+            this.registerHandler(this.serverHandler);
+        }
+
+        // Request-ID aus dem Document laden, wenn vorhanden
+        if (typeof document !== 'undefined') {
+            this.initFromDocument();
+        }
+
+        // Unhandled Errors abfangen
+        this.setupErrorHandling();
+    }
+
+    /**
+     * Debug-Nachricht loggen
+     */
+    static debug(...args) {
+        this.log('debug', ...args);
+    }
+
+    /**
+     * Info-Nachricht loggen
+     */
+    static info(...args) {
+        this.log('info', ...args);
+    }
+
+    /**
+     * Warnungs-Nachricht loggen
+     */
+    static warn(...args) {
+        this.log('warn', ...args);
+    }
+
+    /**
+     * Fehler-Nachricht loggen
+     */
+    static error(...args) {
+        this.log('error', ...args);
+    }
+
+    /**
+     * Log-Nachricht mit beliebigem Level erstellen
+     */
+    static log(level, ...args) {
+        if (!this.config.enabled) return;
+
+        // Level-Validierung
+        const validLevels = ['debug', 'info', 'warn', 'error'];
+        if (!validLevels.includes(level)) {
+            level = 'info';
+        }
+
+        // Nachricht und Kontext extrahieren
+        const message = this.formatMessage(args);
+        const context = args.find(arg => typeof arg === 'object' && arg !== null && !(arg instanceof Error)) || {};
+
+        // Exception extrahieren, falls vorhanden
+        const error = args.find(arg => arg instanceof Error);
+        if (error) {
+            context.exception = error;
+        }
+
+        // Log-Record erstellen
+        let record = {
+            level,
+            message,
+            context,
+            timestamp: new Date(),
+            extra: {},
+        };
+
+        // Alle Processors durchlaufen
+        this.processors.forEach(processor => {
+            record = processor(record);
+        });
+
+        // Log-Level-Prüfung (nach Processors, da sie das Level ändern könnten)
+        const levelPriority = {
+            debug: 100,
+            info: 200,
+            warn: 300,
+            error: 400,
+        };
+
+        if (levelPriority[record.level] < levelPriority[this.config.minLevel]) {
+            return;
+        }
+
+        // Alle Handler durchlaufen
+        this.handlers.forEach(handler => {
+            handler(record);
+        });
+    }
+
+    /**
+     * Nachricht aus verschiedenen Argumenten formatieren
+     */
+    static formatMessage(args) {
+        return args
+            .filter(arg => !(arg instanceof Error) && (typeof arg !== 'object' || arg === null))
+            .map(arg => String(arg))
+            .join(' ');
+    }
+
+    /**
+     * Processor registrieren
+     */
+    static registerProcessor(processor) {
+        if (typeof processor !== 'function') return;
+        this.processors.push(processor);
+    }
+
+    /**
+     * Handler registrieren
+     */
+    static registerHandler(handler) {
+        if (typeof handler !== 'function') return;
+        this.handlers.push(handler);
+    }
+
+    /**
+     * Error-Handling-Setup
+     */
+    static setupErrorHandling() {
+        if (typeof window !== 'undefined') {
+            // Unbehandelte Fehler abfangen
+            window.addEventListener('error', (event) => {
+                this.error('Unbehandelter Fehler:', event.error || event.message);
+            });
+
+            // Unbehandelte Promise-Rejects abfangen
+            window.addEventListener('unhandledrejection', (event) => {
+                this.error('Unbehandelte Promise-Ablehnung:', event.reason);
+            });
+        }
+    }
+
+    /**
+     * Request-ID aus dem Document laden
+     */
+    static initFromDocument() {
+        const meta = document.querySelector('meta[name="request-id"]');
+        if (meta) {
+            const fullRequestId = meta.getAttribute('content');
+            // Nur den ID-Teil ohne Signatur verwenden
+            this.requestId = fullRequestId.split('.')[0] || null;
+        }
+    }
+
+    /*** STANDARD-PROCESSORS ***/
+
+    /**
+     * Processor für Request-ID
+     */
+    static requestIdProcessor(record) {
+        if (Logger.requestId) {
+            record.extra.request_id = Logger.requestId;
+        }
+        return record;
+    }
+
+    /**
+     * Processor für Timestamp-Formatierung
+     */
+    static timestampProcessor(record) {
+        record.formattedTimestamp = record.timestamp.toLocaleTimeString('de-DE');
+        return record;
+    }
+
+    /*** STANDARD-HANDLERS ***/
+
+    /**
+     * Handler für Console-Ausgabe
+     */
+    static consoleHandler(record) {
+        const levelColors = {
+            debug: 'color: gray',
+            info: 'color: green',
+            warn: 'color: orange',
+            error: 'color: red',
+        };
+
+        const color = levelColors[record.level] || 'color: black';
+        const requestIdStr = record.extra.request_id ? `[${record.extra.request_id}] ` : '';
+        const formattedMessage = `[${record.formattedTimestamp}] [${record.level.toUpperCase()}] ${requestIdStr}${record.message}`;
+
+        // Farbige Ausgabe in der Konsole
+        console[record.level](
+            `%c${formattedMessage}`,
+            color,
+            ...(record.context ? [record.context] : [])
+        );
+    }
+
+    /**
+     * Handler für Server-Kommunikation
+     */
+    static serverHandler(record) {
+        fetch(Logger.config.apiEndpoint, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'X-Request-ID': Logger.requestId || ''
+            },
+            body: JSON.stringify({
+                level: record.level,
+                message: record.message,
+                context: record.context || {}
+            })
+        })
+        .then(response => {
+            // Request-ID aus dem Header extrahieren
+            const requestId = response.headers.get('X-Request-ID');
+            if (requestId) {
+                // Nur den ID-Teil ohne Signatur speichern
+                const idPart = requestId.split('.')[0];
+                if (idPart) {
+                    Logger.requestId = idPart;
+                }
+            }
+            return response.json();
+        })
+        .catch(() => {
+            // Fehler beim Senden des Logs ignorieren (keine rekursive Fehlerbehandlung)
+        });
+    }
+}
+
+// Standard-Initialisierung
+Logger.initialize();
diff --git a/resources/js/core/logger.js b/resources/js/core/logger.js
new file mode 100644
index 00000000..a92c8446
--- /dev/null
+++ b/resources/js/core/logger.js
@@ -0,0 +1,37 @@
+import {monitor} from "./frameloop";
+
+export class Logger {
+    static enabled = true //import.meta.env.MODE !== 'production';
+
+    static log(...args) {
+        this._write('log', '[LOG]', args);
+    }
+
+    static warn(...args) {
+        this._write('warn', '[WARN]', args)
+    }
+
+    static info(...args) {
+        this._write('info', '[INFO]', args);
+    }
+
+    static error(...args) {
+        this._write('error', '[ERROR]', args);
+    }
+
+    static _write(consoleMethod, prefix, args) {
+        if(!this.enabled) return;
+
+        const date = new Date();
+        const timestamp = date.toLocaleTimeString('de-DE');
+
+        const msg = `${prefix} [${timestamp}] ${args.map(a => typeof a === 'object' ? JSON.stringify(a) : a).join(' ')}`;
+
+        if(typeof console[consoleMethod] === 'function') {
+            console[consoleMethod](msg);
+        }
+
+        monitor?.log(msg)
+
+    }
+}
diff --git a/resources/js/core/navigateTo.js b/resources/js/core/navigateTo.js
new file mode 100644
index 00000000..ae9c84ca
--- /dev/null
+++ b/resources/js/core/navigateTo.js
@@ -0,0 +1,51 @@
+// modules/core/navigateTo.js
+import { getPrefetched } from './ClickManager.js';
+
+/**
+ * Funktion für SPA-Navigation mit optionaler ViewTransition
+ * Diese Funktion kann als generische Utility überall eingebunden werden!
+ *
+ * @param {string} href - Die Ziel-URL
+ * @param {object} options - Steueroptionen
+ * @param {boolean} [options.replace=false] - history.replaceState statt push
+ * @param {boolean} [options.viewTransition=false] - ViewTransition API verwenden
+ * @param {Function} [options.onUpdate] Wird nach Laden des HTML aufgerufen (html)
+ * @param {Function} [options.getPrefetched] Funktion zum Abrufen gecachter Daten (optional)
+ */
+export async function navigateTo(href, options = {}) {
+    const {
+        replace = false,
+        viewTransition = false,
+        onUpdate = html => {},
+        getPrefetched = null
+        /*onUpdate = (html) => {
+            const container = document.querySelector('main');
+            if (container) container.innerHTML = html;
+        }*/
+    } = options;
+
+    const fetchHtml = async () => {
+
+        let html = '';
+        if(getPrefetched) {
+            html = getPrefetched(href) || '';
+        }
+
+        if(!html) {
+            html = await fetch(href).then(r => r.text());
+        }
+
+        onUpdate(html);
+        if(replace) {
+            history.replaceState(null, '', href);
+        } else {
+            history.pushState(null, '', href);
+        }
+    };
+
+    if (viewTransition && document.startViewTransition) {
+        document.startViewTransition(fetchHtml);
+    } else {
+        await fetchHtml();
+    }
+}
diff --git a/resources/js/core/removeModules.js b/resources/js/core/removeModules.js
new file mode 100644
index 00000000..4419c70a
--- /dev/null
+++ b/resources/js/core/removeModules.js
@@ -0,0 +1,14 @@
+// modules/core/removeModules.js
+import { EventManager } from './EventManager.js';
+
+/**
+ * Entfernt alle bekannten Events zu einem Array von Modulen
+ * Optional: Logging oder Cleanup-Hooks ergänzbar
+ */
+export function removeModules(moduleList) {
+    if (!Array.isArray(moduleList)) return;
+
+    moduleList.forEach((module) => {
+        EventManager.removeModule(module);
+    });
+}
diff --git a/resources/js/core/router.js b/resources/js/core/router.js
new file mode 100644
index 00000000..efdba4df
--- /dev/null
+++ b/resources/js/core/router.js
@@ -0,0 +1,138 @@
+// modules/core/router.js
+import { init as initClickManager } from './ClickManager.js';
+import { navigateTo } from './navigateTo.js';
+
+const routes = new Map();
+const wildcards = [];
+const guards = new Map();
+
+let currentRoute = null;
+let layoutCallback = null;
+let metaCallback = null;
+
+/**
+ * Registriert eine neue Route mit optionalem Handler
+ * @param {string} path - Pfad der Route
+ * @param {Function} handler - Callback bei Treffer
+ */
+export function defineRoute(path, handler) {
+    if (path.includes('*')) {
+        wildcards.push({ pattern: new RegExp('^' + path.replace('*', '.*') + '$'), handler });
+    } else {
+        routes.set(path, handler);
+    }
+}
+
+/**
+ * Definiert einen Guard für eine Route
+ * @param {string} path - Pfad
+ * @param {Function} guard - Guard-Funktion (return false = block)
+ */
+export function guardRoute(path, guard) {
+    guards.set(path, guard);
+}
+
+/**
+ * Gibt die aktuell aktive Route zurück
+ */
+export function getRouteContext() {
+    return currentRoute;
+}
+
+/**
+ * Setzt eine Callback-Funktion für dynamische Layout-Switches
+ */
+export function onLayoutSwitch(fn) {
+    layoutCallback = fn;
+}
+
+/**
+ * Setzt eine Callback-Funktion für Meta-Daten (z. B. title, theme)
+ */
+export function onMetaUpdate(fn) {
+    metaCallback = fn;
+}
+
+function matchRoute(href) {
+    if (routes.has(href)) return routes.get(href);
+    for (const entry of wildcards) {
+        if (entry.pattern.test(href)) return entry.handler;
+    }
+    return null;
+}
+
+function runGuard(href) {
+    const guard = guards.get(href);
+    return guard ? guard(href) !== false : true;
+}
+
+function extractMetaFromHTML(html) {
+    const temp = document.createElement('div');
+    temp.innerHTML = html;
+    const metaTags = {};
+    temp.querySelectorAll('[data-meta]').forEach(el => {
+        for (const attr of el.attributes) {
+            if (attr.name.startsWith('data-meta-')) {
+                const key = attr.name.replace('data-meta-', '');
+                metaTags[key] = attr.value;
+            }
+        }
+    })
+    //const title = temp.querySelector('[data-meta-title]')?.getAttribute('data-meta-title');
+    //const theme = temp.querySelector('[data-meta-theme]')?.getAttribute('data-meta-theme');
+    return { metaTags };
+}
+
+function animateLayoutSwitch(type) {
+    document.body.dataset.layout = type;
+    document.body.classList.add('layout-transition');
+    setTimeout(() => document.body.classList.remove('layout-transition'), 300);
+}
+
+/**
+ * Startet den Router
+ */
+export function startRouter() {
+    initClickManager((href, link, options) => {
+        if (!runGuard(href)) return;
+
+        if (options.modal) {
+            const handler = matchRoute(href);
+            currentRoute = { href, modal: true, link, options };
+            handler?.(currentRoute);
+            layoutCallback?.(currentRoute);
+            metaCallback?.(currentRoute);
+        } else {
+            navigateTo(href, {
+                ...options,
+                onUpdate: (html) => {
+                    const container = document.querySelector('main');
+                    if (container) container.innerHTML = html;
+
+                    const routeHandler = matchRoute(href);
+                    currentRoute = { href, html, modal: false };
+
+                    const meta = extractMetaFromHTML(html);
+                    if (meta.title) document.title = meta.title;
+                    if (meta.theme) document.documentElement.style.setProperty('--theme-color', meta.theme);
+
+                    routeHandler?.(currentRoute);
+                    layoutCallback?.(currentRoute);
+                    metaCallback?.(currentRoute);
+                }
+            });
+        }
+    });
+
+    // Bei Seitenstart erste Route prüfen
+    window.addEventListener('DOMContentLoaded', () => {
+        const href = location.pathname;
+        const routeHandler = matchRoute(href);
+        currentRoute = { href, modal: false };
+        routeHandler?.(currentRoute);
+        layoutCallback?.(currentRoute);
+        metaCallback?.(currentRoute);
+    });
+}
+
+export { animateLayoutSwitch, extractMetaFromHTML };
diff --git a/resources/js/core/secureLogger.js b/resources/js/core/secureLogger.js
new file mode 100644
index 00000000..0cb97739
--- /dev/null
+++ b/resources/js/core/secureLogger.js
@@ -0,0 +1,99 @@
+/**
+ * Erweiterter Logger mit Request-ID-Unterstützung und Server-Kommunikation.
+ */
+export class SecureLogger {
+    static enabled = true;
+    static apiEndpoint = '/api/log';
+    static requestId = null;
+
+    static log(...args) {
+        this._write('log', args);
+    }
+
+    static warn(...args) {
+        this._write('warn', args)
+    }
+
+    static info(...args) {
+        this._write('info', args);
+    }
+
+    static error(...args) {
+        this._write('error', args);
+    }
+
+    static _write(level, args) {
+        if(!this.enabled) return;
+
+        const date = new Date();
+        const timestamp = date.toLocaleTimeString('de-DE');
+        const requestIdStr = this.requestId ? `[${this.requestId}] ` : '';
+
+        const message = args.map(a => typeof a === 'object' ? JSON.stringify(a) : a).join(' ');
+        const formattedMessage = `[${timestamp}] ${requestIdStr}[${level.toUpperCase()}] ${message}`;
+
+        // Lokales Logging in der Konsole
+        console[level](formattedMessage);
+
+        // An den Server senden (wenn nicht in Produktion)
+        this._sendToServer(level, message, args.find(a => typeof a === 'object'));
+    }
+
+    static _sendToServer(level, message, context) {
+        fetch(this.apiEndpoint, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'X-Request-ID': this.requestId || ''
+            },
+            body: JSON.stringify({
+                level,
+                message,
+                context
+            })
+        })
+        .then(response => {
+            // Request-ID aus dem Header extrahieren
+            const requestId = response.headers.get('X-Request-ID');
+            if (requestId) {
+                // Nur den ID-Teil ohne Signatur speichern
+                const idPart = requestId.split('.')[0];
+                if (idPart) {
+                    this.requestId = idPart;
+                }
+            }
+            return response.json();
+        })
+        .catch(err => {
+            console.error('Fehler beim Senden des Logs:', err);
+        });
+    }
+
+    /**
+     * Request-ID aus dem Document laden
+     */
+    static initFromDocument() {
+        // Versuche die Request-ID aus einem Meta-Tag zu lesen
+        const meta = document.querySelector('meta[name="request-id"]');
+        if (meta) {
+            const fullRequestId = meta.getAttribute('content');
+            // Nur den ID-Teil ohne Signatur verwenden
+            this.requestId = fullRequestId.split('.')[0] || null;
+        }
+    }
+}
+
+// Request-ID initialisieren, wenn das DOM geladen ist
+document.addEventListener('DOMContentLoaded', () => {
+    SecureLogger.initFromDocument();
+
+    // Abfangen aller unbehandelten Fehler und Logging
+    window.addEventListener('error', (event) => {
+        SecureLogger.error('Unbehandelter Fehler:', event.error || event.message);
+    });
+
+    // Abfangen aller unbehandelten Promise-Rejects
+    window.addEventListener('unhandledrejection', (event) => {
+        SecureLogger.error('Unbehandelte Promise-Ablehnung:', event.reason);
+    });
+});
diff --git a/resources/js/core/state.js b/resources/js/core/state.js
new file mode 100644
index 00000000..760178e7
--- /dev/null
+++ b/resources/js/core/state.js
@@ -0,0 +1,213 @@
+// src/core/state.js
+
+const globalState = new Map();
+
+/**
+ * Normale State-Erstellung (nicht persistent)
+ */
+export function createState(key, initialValue) {
+    if (!globalState.has(key)) globalState.set(key, initialValue);
+
+    return {
+        get() {
+            return globalState.get(key);
+        },
+        set(value) {
+            globalState.set(key, value);
+            dispatchEvent(new CustomEvent('statechange', {
+                detail: { key, value }
+            }));
+        },
+        subscribe(callback) {
+            const handler = (event) => {
+                if (event.detail.key === key) {
+                    callback(event.detail.value);
+                }
+            };
+            addEventListener('statechange', handler);
+            return () => removeEventListener('statechange', handler);
+        }
+    };
+}
+
+/**
+ * Persistent State via localStorage
+ */
+export function createPersistentState(key, defaultValue) {
+    const stored = localStorage.getItem(`state:${key}`);
+    const initial = stored !== null ? JSON.parse(stored) : defaultValue;
+
+    const state = createState(key, initial);
+
+    state.subscribe((val) => {
+        localStorage.setItem(`state:${key}`, JSON.stringify(val));
+    });
+
+    return state;
+}
+
+/**
+ * Zugriff auf alle States (intern)
+ */
+export function getRawState() {
+    return globalState;
+}
+
+/**
+ * Elementbindung: Text, Attribut, Klasse oder Custom-Callback
+ */
+export function bindStateToElement({ state, element, property = 'text', attributeName = null }) {
+    const apply = (value) => {
+        if (property === 'text') {
+            element.textContent = value;
+        } else if (property === 'attr' && attributeName) {
+            element.setAttribute(attributeName, value);
+        } else if (property === 'class') {
+            element.className = value;
+        } else if (typeof property === 'function') {
+            property(element, value);
+        }
+    };
+
+    apply(state.get());
+    return state.subscribe(apply);
+}
+
+/**
+ * Mehrere Elemente gleichzeitig binden
+ */
+export function bindStateToElements({ state, elements, ...rest }) {
+    return elements.map(el => bindStateToElement({ state, element: el, ...rest }));
+}
+
+/**
+ * Declarative Auto-Bindings via data-bind Attribute
+ */
+export function initStateBindings() {
+    document.querySelectorAll('[data-bind]').forEach(el => {
+        const key = el.getAttribute('data-bind');
+        const state = createState(key, '');
+        bindStateToElement({ state, element: el, property: 'text' });
+    });
+
+    document.querySelectorAll('[data-bind-attr]').forEach(el => {
+        const key = el.getAttribute('data-bind-attr');
+        const attr = el.getAttribute('data-bind-attr-name') || 'value';
+        const state = createState(key, '');
+        bindStateToElement({ state, element: el, property: 'attr', attributeName: attr });
+    });
+
+    document.querySelectorAll('[data-bind-class]').forEach(el => {
+        const key = el.getAttribute('data-bind-class');
+        const state = createState(key, '');
+        bindStateToElement({ state, element: el, property: 'class' });
+    });
+
+    document.querySelectorAll('[data-bind-input]').forEach(el => {
+        const key = el.getAttribute('data-bind-input');
+        const persistent = el.hasAttribute('data-persistent');
+        const state = persistent ? createPersistentState(key, '') : createState(key, '');
+
+        bindInputToState(el, state);
+    });
+}
+
+/**
+ * Zwei-Wege-Bindung für Formulareingaben
+ */
+export function bindInputToState(inputEl, state) {
+    // Initialwert setzen
+    if (inputEl.type === 'checkbox') {
+        inputEl.checked = !!state.get();
+    } else {
+        inputEl.value = state.get();
+    }
+
+    // DOM → State
+    inputEl.addEventListener('input', () => {
+        if (inputEl.type === 'checkbox') {
+            state.set(inputEl.checked);
+        } else {
+            state.set(inputEl.value);
+        }
+    });
+
+    // State → DOM
+    return state.subscribe((val) => {
+        if (inputEl.type === 'checkbox') {
+            inputEl.checked = !!val;
+        } else {
+            inputEl.value = val;
+        }
+    });
+}
+
+
+/**
+ * Berechneter Zustand auf Basis anderer States
+ */
+export function createComputedState(dependencies, computeFn) {
+    let value = computeFn(...dependencies.map(d => d.get()));
+    const key = `computed:${Math.random().toString(36).slice(2)}`;
+    const state = createState(key, value);
+
+    dependencies.forEach(dep => {
+        dep.subscribe(() => {
+            const newValue = computeFn(...dependencies.map(d => d.get()));
+            state.set(newValue);
+        });
+    });
+
+    return state;
+}
+
+/**
+ * Aktiviert Undo/Redo für einen State
+ */
+export function enableUndoRedoForState(state) {
+    const history = [];
+    let index = -1;
+    let lock = false;
+
+    const record = (val) => {
+        if (lock) return;
+        history.splice(index + 1); // zukünftige States verwerfen
+        history.push(val);
+        index++;
+    };
+
+    record(state.get());
+
+    const unsubscribe = state.subscribe((val) => {
+        if (!lock) record(val);
+    });
+
+    return {
+        undo() {
+            if (index > 0) {
+                lock = true;
+                index--;
+                state.set(history[index]);
+                lock = false;
+            }
+        },
+        redo() {
+            if (index < history.length - 1) {
+                lock = true;
+                index++;
+                state.set(history[index]);
+                lock = false;
+            }
+        },
+        destroy: unsubscribe
+    };
+}
+
+/**
+ * Dev-Konsole zur Nachverfolgung von State-Änderungen
+ */
+export function enableStateLogging(state, label = 'state') {
+    state.subscribe((val) => {
+        console.debug(`[State Change: ${label}]`, val);
+    });
+}
diff --git a/resources/js/core/useEvent.js b/resources/js/core/useEvent.js
new file mode 100644
index 00000000..1090c2b8
--- /dev/null
+++ b/resources/js/core/useEvent.js
@@ -0,0 +1,23 @@
+// modules/core/useEvent.js
+import { EventManager } from './EventManager.js';
+
+/**
+ * Vereinfachte Kurzform zur Registrierung eines EventListeners
+ *
+ * @param {EventTarget} target - Das Element, auf das der Event gehört
+ * @param {string} type - Der Eventtyp (z.B. 'click')
+ * @param {Function} handler - Die Callback-Funktion
+ * @param {object} meta - Optionen oder automatisch aus `import.meta` (optional)
+ * @param {Object|boolean} options - EventListener-Optionen
+ */
+export function useEvent(target, type, handler, meta = import.meta, options = false) {
+    const module = typeof meta === 'string'
+        ? meta
+        : (meta.url?.split('/').slice(-2, -1)[0] || 'unknown');
+
+    EventManager.add(target, type, handler, { module, options });
+
+    return () => {
+        EventManager.removeModule(module);
+    }
+}
diff --git a/resources/js/docs/SCROLLER.md b/resources/js/docs/SCROLLER.md
new file mode 100644
index 00000000..20a943a8
--- /dev/null
+++ b/resources/js/docs/SCROLLER.md
@@ -0,0 +1,115 @@
+# 📦 Scroll-Module – Anwendung und Integration
+
+Dieses Projekt enthält mehrere leichtgewichtige JavaScript-Module zur Gestaltung interaktiver Scroll-Erlebnisse.
+
+## 🔧 Modulübersicht
+
+| Modul            | Funktion                            |
+|------------------|-------------------------------------|
+| `scroll-timeline` | Zustandswechsel bei Scrollschritten |
+| `parallax`        | Parallax-Scrolling-Effekte          |
+| `sticky-steps`    | Scrollbasierte Sticky-Kapitel       |
+
+---
+
+## 1️⃣ scroll-timeline
+
+### 📄 Verwendung
+```html
+<section data-scroll-step="1">Intro</section>
+<section data-scroll-step="2">Chart</section>
+<section data-scroll-step="3">Zitat</section>
+```
+
+### ⚙️ Konfiguration
+```js
+init({
+  attribute: 'data-scroll-step', // Attributname
+  triggerPoint: 0.4,             // Auslösehöhe (in % der Viewporthöhe)
+  once: false                    // true = nur einmal triggern
+});
+```
+
+### 🎯 Callbacks (in steps.js)
+```js
+export const scrollSteps = {
+  onEnter(index, el) {
+    // Element wird aktiv
+  },
+  onLeave(index, el) {
+    // Element verlässt Fokus (wenn once = false)
+  }
+};
+```
+
+---
+
+## 2️⃣ parallax
+
+### 📄 Verwendung
+```html
+<img src="..." data-parallax data-parallax-speed="0.2">
+```
+
+### ⚙️ Konfiguration
+```js
+init({
+  selector: '[data-parallax]',       // Ziel-Selektor
+  speedAttr: 'data-parallax-speed', // Attribut für Geschwindigkeit
+  defaultSpeed: 0.5                  // Fallback-Geschwindigkeit
+});
+```
+
+### 💡 Hinweis
+Je niedriger die `speed`, desto "langsamer" scrollt das Element.
+
+---
+
+## 3️⃣ sticky-steps
+
+### 📄 Verwendung
+```html
+<div data-sticky-container>
+  <div data-sticky-step>Kapitel 1</div>
+  <div data-sticky-step>Kapitel 2</div>
+</div>
+```
+
+### ⚙️ Konfiguration
+```js
+init({
+  containerSelector: '[data-sticky-container]',
+  stepSelector: '[data-sticky-step]',
+  activeClass: 'is-sticky-active'
+});
+```
+
+### 🎨 CSS-Vorschlag
+```css
+[data-sticky-step] {
+  position: sticky;
+  top: 20vh;
+  opacity: 0.3;
+  transition: opacity 0.3s ease;
+}
+
+.is-sticky-active {
+  opacity: 1;
+}
+```
+
+---
+
+## 🚀 Integration in dein Framework
+
+- Jedes Modul exportiert eine `init()`-Funktion
+- Wird automatisch über `modules/index.js` geladen
+- Konfiguration erfolgt über `modules/config.js`
+
+```js
+export const moduleConfig = {
+  'scroll-timeline': { once: false },
+  'parallax': { defaultSpeed: 0.3 },
+  'sticky-steps': { activeClass: 'active' }
+};
+```
diff --git a/resources/js/docs/SCROLL_LOOP.md b/resources/js/docs/SCROLL_LOOP.md
new file mode 100644
index 00000000..fcde32b2
--- /dev/null
+++ b/resources/js/docs/SCROLL_LOOP.md
@@ -0,0 +1,9 @@
+| Attribut            | Typ                                                        | Standardwert  | Beschreibung                                                              |
+| ------------------- | ---------------------------------------------------------- | ------------- | ------------------------------------------------------------------------- |
+| `data-scroll-loop`  | —                                                          | —             | Aktiviert das Scroll-Loop-Modul auf dem Element                           |
+| `data-scroll-speed` | `float`                                                    | `0.2`         | Faktor für Scrollgeschwindigkeit – positiv oder negativ                   |
+| `data-scroll-axis`  | `"x"` \| `"y"`                                             | `"y"`         | Achse der Bewegung                                                        |
+| `data-scroll-type`  | `"translate"` \| `"rotate"` \| `"background"` \| `"scale"` | `"translate"` | Art der Scrollanimation                                                   |
+| `data-loop-offset`  | `float`                                                    | `0`           | Start-Offset in Pixeln (nützlich für Desynchronisation mehrerer Elemente) |
+| `data-loop-limit`   | `number` (Pixelwert)                                       | —             | Obergrenze für Scrollbereich – ab dieser Position stoppt die Animation    |
+| `data-loop-pause`   | `"true"` \| `"false"`                                      | —             | Bei `"true"` wird die Animation bei Hover oder aktivem Element pausiert   |
diff --git a/resources/js/docs/prefetch.md b/resources/js/docs/prefetch.md
new file mode 100644
index 00000000..2b3545fb
--- /dev/null
+++ b/resources/js/docs/prefetch.md
@@ -0,0 +1,29 @@
+
+---
+
+## 🔧 Neue Funktionen:
+
+### `getPrefetched(href: string): string | null`
+
+* Gibt den HTML-Text zurück, **falls gültig gecached**
+* Sonst `null`
+
+### `prefetchHref(href: string): void`
+
+* Manuelles Prefetching von URLs
+* Wird nur ausgeführt, wenn nicht bereits gecached
+
+---
+
+## 🧪 Verwendung:
+
+```js
+import { getPrefetched, prefetchHref } from './core/click-manager.js';
+
+prefetchHref('/about.html'); // manuelles Prefetching
+
+const html = getPrefetched('/about.html');
+if (html) {
+  render(html);
+}
+```
diff --git a/resources/js/docs/router.md b/resources/js/docs/router.md
new file mode 100644
index 00000000..492a0fc5
--- /dev/null
+++ b/resources/js/docs/router.md
@@ -0,0 +1,34 @@
+✅ Dein Router-Modul wurde erweitert um:
+
+---
+
+## 🎭 Layout-Animation
+
+```js
+import { animateLayoutSwitch } from './router.js';
+
+onLayoutSwitch(ctx => {
+  const type = ctx.href.startsWith('/studio') ? 'studio' : 'default';
+  animateLayoutSwitch(type);
+});
+```
+
+→ Fügt `data-layout="…"`, animiert via `.layout-transition` (z. B. Fade)
+
+---
+
+## 📝 Meta-Daten aus HTML
+
+```html
+<div data-meta-title="Über Uns" data-meta-theme="#111"></div>
+```
+
+→ Beim Laden des HTML werden automatisch:
+
+* `document.title` gesetzt
+* CSS-Variable `--theme-color` aktualisiert
+
+---
+
+Wenn du möchtest, kann ich dir nun einen `<meta name="theme-color">`-Updater bauen oder eine ViewTransition speziell für Layoutwechsel. Sag einfach:
+**„Ja, bitte meta\[name=theme-color]“** oder **„ViewTransition für Layout“**.
diff --git a/resources/js/docs/state.md b/resources/js/docs/state.md
new file mode 100644
index 00000000..6e15b1d3
--- /dev/null
+++ b/resources/js/docs/state.md
@@ -0,0 +1,197 @@
+# 📦 Framework-Module: `state.js` & `events.js`
+
+Diese Dokumentation beschreibt die Verwendung der globalen **State-Verwaltung** und des **Event-/Action-Dispatching** in deinem Framework.
+
+---
+
+## 📁 `core/state.js` – Globale Zustandsverwaltung
+
+### 🔹 `createState(key, initialValue)`
+
+Erzeugt einen flüchtigen (nicht-persistenten) globalen Zustand.
+
+```js
+const username = createState('username', 'Gast');
+
+console.log(username.get()); // → "Gast"
+
+username.set('Michael');
+```
+
+---
+
+### 🔹 `createPersistentState(key, defaultValue)`
+
+Wie `createState`, aber mit `localStorage`-Speicherung.
+
+```js
+const theme = createPersistentState('theme', 'light');
+theme.set('dark'); // Wird gespeichert
+```
+
+---
+
+### 🔹 `state.subscribe(callback)`
+
+Reagiert auf Änderungen des Zustands.
+
+```js
+username.subscribe((val) => {
+    console.log('Neuer Benutzername:', val);
+});
+```
+
+---
+
+### 🔹 `bindStateToElement({ state, element, property, attributeName })`
+
+Bindet einen State an ein DOM-Element.
+
+```js
+bindStateToElement({
+    state: username,
+    element: document.querySelector('#userDisplay'),
+    property: 'text'
+});
+```
+
+```html
+<span id="userDisplay"></span>
+```
+
+---
+
+### 🔹 `bindInputToState(inputElement, state)`
+
+Erzeugt eine **Zwei-Wege-Bindung** zwischen Eingabefeld und State.
+
+```js
+bindInputToState(document.querySelector('#nameInput'), username);
+```
+
+```html
+<input id="nameInput" type="text" />
+```
+
+---
+
+### 🔹 `initStateBindings()`
+
+Initialisiert alle Elemente mit `data-bind-*` automatisch.
+
+```html
+<!-- Einfache Textbindung -->
+<span data-bind="username"></span>
+
+<!-- Input mit persistenter Speicherung -->
+<input data-bind-input="username" data-persistent />
+
+<!-- Attributbindung -->
+<img data-bind-attr="profilePic" data-bind-attr-name="src" />
+
+<!-- Klassenbindung -->
+<div data-bind-class="themeClass"></div>
+```
+
+```js
+initStateBindings(); // Einmalig in initApp() aufrufen
+```
+
+---
+
+### 🔹 `createComputedState([dependencies], computeFn)`
+
+Leitet einen State aus anderen ab.
+
+```js
+const first = createState('first', 'Max');
+const last = createState('last', 'Mustermann');
+
+const fullName = createComputedState([first, last], (f, l) => \`\${f} \${l}\`);
+```
+
+---
+
+### 🔹 `enableUndoRedoForState(state)`
+
+Fügt Undo/Redo-Funktionalität hinzu.
+
+```js
+const message = createState('message', '');
+const history = enableUndoRedoForState(message);
+
+history.undo();
+history.redo();
+```
+
+---
+
+### 🔹 `enableStateLogging(state, label?)`
+
+Gibt alle Änderungen in der Konsole aus.
+
+```js
+enableStateLogging(username, 'Benutzername');
+```
+
+---
+
+## 📁 `core/events.js` – EventBus & ActionDispatcher
+
+### 🔹 `on(eventName, callback)`
+
+Abonniert benutzerdefinierte Events.
+
+```js
+on('user:login', user => {
+    console.log('Login:', user.name);
+});
+```
+
+---
+
+### 🔹 `emit(eventName, payload)`
+
+Sendet ein Event global.
+
+```js
+emit('user:login', { name: 'Max', id: 123 });
+```
+
+---
+
+### 🔹 `registerActionListener(callback)`
+
+Reagiert auf alle ausgelösten Aktionen.
+
+```js
+registerActionListener(({ type, payload }) => {
+    if (type === 'counter/increment') {
+        payload.state.set(payload.state.get() + 1);
+    }
+});
+```
+
+---
+
+### 🔹 `dispatchAction(type, payload?)`
+
+Löst eine benannte Aktion aus.
+
+```js
+dispatchAction('counter/increment', { state: counter });
+```
+
+---
+
+## ✅ Zusammenfassung
+
+| Funktion | Zweck |
+|----------|-------|
+| `createState` / `createPersistentState` | Reaktiver globaler Zustand |
+| `bindStateToElement` / `bindInputToState` | DOM-Bindings |
+| `createComputedState` | Abhängiger Zustand |
+| `enableUndoRedoForState` | History / Undo |
+| `enableStateLogging` | Debugging |
+| `on` / `emit` | Lose gekoppelte Event-Kommunikation |
+| `registerActionListener` / `dispatchAction` | Zentrale Aktionssteuerung |
diff --git a/resources/js/main.js b/resources/js/main.js
index 81faac4f..ca3c820b 100644
--- a/resources/js/main.js
+++ b/resources/js/main.js
@@ -1 +1,48 @@
 import '../css/styles.css';
+
+import { initApp } from './core/init.js';
+
+// resources/js/app.js (dein Einstiegspunkt)
+import { registerSW } from 'virtual:pwa-register';
+
+const updateSW = registerSW({
+    onNeedRefresh() {
+        const reload = confirm('🔄 Neue Version verfügbar. Seite neu laden?');
+        if (reload) updateSW(true);
+    },
+    onOfflineReady() {
+        console.log('📦 Offline-Inhalte sind bereit.');
+    }
+});
+
+registerSW({
+    onRegistered(reg) {
+        console.log('Service Worker registriert:', reg);
+    },
+    onRegisterError(error) {
+        console.error('Service Worker Fehler:', error);
+    }
+});
+
+document.addEventListener("DOMContentLoaded", () => {
+    initApp();
+});
+
+function isHtmlAttributeSupported(elementName, attribute) {
+    const element = document.createElement(elementName);
+    return attribute in element;
+}
+
+
+let closedAttr = document.getElementById('my-dialog');
+if(! 'closedby' in closedAttr) {
+    alert('oh no');
+}
+
+/*
+if (isHtmlAttributeSupported('dialog', 'closedby')) {
+    alert('Attribut wird unterstützt!');
+} else {
+    alert('Nicht unterstützt!');
+}
+*/
diff --git a/resources/js/modules/config.js b/resources/js/modules/config.js
new file mode 100644
index 00000000..ec5a7159
--- /dev/null
+++ b/resources/js/modules/config.js
@@ -0,0 +1,25 @@
+export const moduleConfig = {
+    'noise': {
+        selector: '.noise-overlay',
+        toggleKey: 'g',
+        className: 'grainy',
+        enableTransition: true
+    },
+    'shortcut-handler.js': {
+        debug: false
+    },
+    'scrollfx': {
+        selector: '.fade-in-on-scroll, .zoom-in',
+        offset: 0.8,
+        baseDelay: 0.075,
+        once: true
+    },
+    'scroll-timeline': {
+        attribute: 'data-scroll-step',
+        triggerPoint: 0.4,
+        once: false
+    },
+    'smooth-scroll': {
+        'speed': 0.2,
+    }
+};
diff --git a/resources/js/modules/example-module/index.js b/resources/js/modules/example-module/index.js
new file mode 100644
index 00000000..14a3cd6d
--- /dev/null
+++ b/resources/js/modules/example-module/index.js
@@ -0,0 +1,37 @@
+// modules/example-module/index.js
+import { registerFrameTask, unregisterFrameTask } from '../../core/frameloop.js';
+
+let frameId = 'example-module';
+let resizeHandler = null;
+
+export function init(config = {}) {
+    console.log('[example-module] init');
+
+    // z. B. Event-Listener hinzufügen
+    resizeHandler = () => {
+        console.log('Fenstergröße geändert');
+    };
+    window.addEventListener('resize', resizeHandler);
+
+    // Scroll- oder Frame-Logik
+    registerFrameTask(frameId, () => {
+        // wiederkehrende Aufgabe
+        const scrollY = window.scrollY;
+        // ggf. transformieren oder Werte speichern
+    }, { autoStart: true });
+}
+
+export function destroy() {
+    console.log('[example-module] destroy');
+
+    // EventListener entfernen
+    if (resizeHandler) {
+        window.removeEventListener('resize', resizeHandler);
+        resizeHandler = null;
+    }
+
+    // FrameTask entfernen
+    unregisterFrameTask(frameId);
+
+    // weitere Aufräumarbeiten, z.B. Observer disconnect
+}
diff --git a/resources/js/modules/index.js b/resources/js/modules/index.js
new file mode 100644
index 00000000..3b927a58
--- /dev/null
+++ b/resources/js/modules/index.js
@@ -0,0 +1,47 @@
+import { moduleConfig } from './config.js';
+import { Logger } from '../core/logger.js';
+
+export const activeModules = new Map(); // key: modulename → { mod, config }
+
+export async function registerModules() {
+    const modules = import.meta.glob('./*/index.js', { eager: true });
+
+    const domModules = new Set(
+        Array.from(document.querySelectorAll('[data-module]')).map(el => el.dataset.module).filter(Boolean)
+    );
+
+    const usedModules = new Set(domModules);
+    const fallbackMode = usedModules.size === 0;
+
+    Object.entries(modules).forEach(([path, mod]) => {
+        const name = path.split('/').slice(-2, -1)[0]; // z.B. "noise-toggle.js"
+        const config = moduleConfig[name] || {};
+
+        if(!fallbackMode && !usedModules.has(name)) {
+            Logger.info(`⏭️ [Module] Skipped (not used in DOM): ${name}`);
+            return;
+        }
+
+        if (typeof mod.init === 'function') {
+            mod.init(config);
+            activeModules.set(name, { mod, config });
+            Logger.info(`✅ [Module] Initialized: ${name}`);
+        } else {
+            Logger.warn(`⛔ [Module] No init() in ${name}`);
+        }
+    });
+
+    if (fallbackMode) {
+        Logger.info('⚠️ [Module] No data-module usage detected, fallback to full init mode');
+    }
+}
+
+export function destroyModules() {
+    for (const [name, { mod }] of activeModules.entries()) {
+        if (typeof mod.destroy === 'function') {
+            mod.destroy();
+            Logger.info(`🧹 [Module] Destroyed: ${name}`);
+        }
+    }
+    activeModules.clear();
+}
diff --git a/resources/js/modules/inertia-scroll/index.js b/resources/js/modules/inertia-scroll/index.js
new file mode 100644
index 00000000..4fc16879
--- /dev/null
+++ b/resources/js/modules/inertia-scroll/index.js
@@ -0,0 +1,63 @@
+// modules/inertia-scroll/index.js
+import { registerFrameTask, unregisterFrameTask } from '../../core/frameloop.js';
+
+let taskId = 'inertia-scroll';
+let velocity = 0;
+let lastY = window.scrollY;
+let active = false;
+let scrollEndTimer;
+let damping = 0.9;
+let minVelocity = 0.2;
+
+export function init(config = {}) {
+    damping = typeof config.damping === 'number' ? config.damping : 0.9;
+
+    minVelocity = typeof config.minVelocity === 'number' ? contig.minVelocity : 0.1;
+
+    window.addEventListener('scroll', onScroll, { passive: true });
+
+    registerFrameTask(taskId, () => {
+        const root = document.documentElement;
+        const scrollY = window.scrollY;
+        const delta = scrollY - lastY;
+        const direction = delta > 0 ? 'down' : delta < 0 ? 'up' : 'none';
+        const speed = Math.abs(delta);
+
+        if (!active && Math.abs(velocity) > minVelocity) {
+            window.scrollTo(0, scrollY + velocity);
+            velocity *= damping; // Trägheit / Dämpfung
+            root.dataset.scrollState = 'inertia';
+        } else if (active) {
+            velocity = delta;
+            lastY = scrollY;
+            root.dataset.scrollState = 'active';
+        } else {
+            delete root.dataset.scrollState;
+        }
+
+        root.dataset.scrollDirection = direction;
+        root.dataset.scrollSpeed = speed.toFixed(2);
+    }, { autoStart: true });
+}
+
+function onScroll() {
+    active = true;
+    clearTimeout(scrollEndTimer);
+    scrollEndTimer = setTimeout(() => {
+        active = false;
+    }, 50);
+}
+
+export function destroy() {
+    window.removeEventListener('scroll', onScroll);
+    unregisterFrameTask(taskId);
+    velocity = 0;
+    lastY = window.scrollY;
+    active = false;
+    clearTimeout(scrollEndTimer);
+
+    const root = document.documentElement;
+    delete root.dataset.scrollState;
+    delete root.dataset.scrollDirection;
+    delete root.dataset.scrollSpeed;
+}
diff --git a/resources/js/modules/lightbox-trigger/index.js b/resources/js/modules/lightbox-trigger/index.js
new file mode 100644
index 00000000..2e1d5035
--- /dev/null
+++ b/resources/js/modules/lightbox-trigger/index.js
@@ -0,0 +1,26 @@
+// modules/lightbox-trigger/index.js
+import { UIManager } from '../ui/UIManager.js';
+import { Logger } from '../../core/logger.js';
+import { useEvent } from '../../core/useEvent.js';
+
+function onClick(e) {
+    const img = e.target.closest('[data-lightbox]');
+    if (!img || img.tagName !== 'IMG') return;
+
+    e.preventDefault();
+
+    UIManager.open('lightbox', {
+        content: `<img src="${img.src}" alt="${img.alt || ''}" />`
+    });
+}
+
+export function init() {
+    Logger.info('[lightbox-trigger] init');
+    useEvent(document, 'click', onClick);
+}
+
+export function destroy() {
+    Logger.info('[lightbox-trigger] destroy');
+    // Automatische Entfernung über EventManager erfolgt über Modulkennung
+    // Kein direkter Aufruf nötig, solange removeModules() global verwendet wird
+}
diff --git a/resources/js/modules/noise/index.js b/resources/js/modules/noise/index.js
new file mode 100644
index 00000000..01b0d988
--- /dev/null
+++ b/resources/js/modules/noise/index.js
@@ -0,0 +1,42 @@
+// js/noise-toggle.js
+
+import { Logger } from "../../core/logger.js";
+
+export function init(config = {}) {
+    Logger.log('Noise Toggle Init', config);
+
+    const {
+        selector = ".noise-overlay",
+        toggleKey = "g",
+        className = "grainy",
+        enableTransition = true,
+    } = config;
+
+    const body = document.body;
+    const noiseElement = document.querySelector(selector);
+
+    if (!noiseElement) return;
+
+    const isInput = noiseElement => ["input", "textarea"].includes(noiseElement.tagName.toLowerCase());
+
+    function update() {
+        if (enableTransition) {
+            noiseElement.classList.toggle("hidden", !body.classList.contains(className));
+        } else {
+            noiseElement.style.display = body.classList.contains(className) ? "block" : "none";
+        }
+    }
+
+    update();
+
+    document.addEventListener("keydown", (e) => {
+        if (
+            e.key.toLowerCase() === toggleKey &&
+            !e.ctrlKey && !e.metaKey && !e.altKey &&
+            !isInput(e.target)
+        ) {
+            body.classList.toggle(className);
+            update();
+        }
+    })
+}
diff --git a/resources/js/modules/parallax/index.js b/resources/js/modules/parallax/index.js
new file mode 100644
index 00000000..240c8058
--- /dev/null
+++ b/resources/js/modules/parallax/index.js
@@ -0,0 +1,27 @@
+// modules/parallax/index.js
+import { Logger } from '../../core/logger.js';
+import { registerFrameTask } from '../../core/frameloop.js';
+
+export function init(config = {}) {
+    Logger.info('Parallax init');
+
+    const defaultConfig = {
+        selector: '[data-parallax]',
+        speedAttr: 'data-parallax-speed',
+        defaultSpeed: 0.5
+    };
+
+    const settings = { ...defaultConfig, ...config };
+    const elements = document.querySelectorAll(settings.selector);
+
+    function updateParallax() {
+        const scrollY = window.scrollY;
+        elements.forEach(el => {
+            const speed = parseFloat(el.getAttribute(settings.speedAttr)) || settings.defaultSpeed;
+            const offset = scrollY * speed;
+            el.style.transform = `translateY(${offset}px)`;
+        });
+    }
+
+    registerFrameTask('parallax', updateParallax, { autoStart: true });
+}
diff --git a/resources/js/modules/scroll-loop/index.js b/resources/js/modules/scroll-loop/index.js
new file mode 100644
index 00000000..a1fafdbc
--- /dev/null
+++ b/resources/js/modules/scroll-loop/index.js
@@ -0,0 +1,66 @@
+// modules/scroll-loop/index.js
+import { registerFrameTask } from '../../core/frameloop.js';
+
+export function init(config = {}) {
+    const elements = document.querySelectorAll('[data-scroll-loop]');
+
+    elements.forEach(el => {
+        const type = el.dataset.scrollType || 'translate';
+        if (type === 'translate' && el.children.length === 1) {
+            const clone = el.firstElementChild.cloneNode(true);
+            clone.setAttribute('aria-hidden', 'true');
+            el.appendChild(clone);
+        }
+    });
+
+    registerFrameTask('scroll-loop', () => {
+        const scrollY = window.scrollY;
+        const scrollX = window.scrollX;
+
+        elements.forEach(el => {
+            const factor = parseFloat(el.dataset.scrollSpeed || config.speed || 0.2);
+            const axis = el.dataset.scrollAxis || 'y';
+            const type = el.dataset.scrollType || 'translate';
+            const pause = el.dataset.loopPause === 'true';
+            const offsetStart = parseFloat(el.dataset.loopOffset || 0);
+            const limit = parseFloat(el.dataset.loopLimit || 0);
+
+            const input = axis === 'x' ? scrollX : scrollY;
+            if (limit && input > limit) return;
+            if (pause && (el.matches(':hover') || el.matches(':active'))) return;
+
+            const offset = (input + offsetStart) * factor;
+
+            switch (type) {
+                case 'translate': {
+                    const base = axis === 'x' ? el.offsetWidth : el.offsetHeight;
+                    const value = -(offset % base);
+                    const transform = axis === 'x' ? `translateX(${value}px)` : `translateY(${value}px)`;
+                    el.style.transform = transform;
+                    break;
+                }
+                case 'rotate': {
+                    const deg = offset % 360;
+                    el.style.transform = `rotate(${deg}deg)`;
+                    break;
+                }
+                case 'background': {
+                    const pos = offset % 100;
+                    if (axis === 'x') {
+                        el.style.backgroundPosition = `${pos}% center`;
+                    } else {
+                        el.style.backgroundPosition = `center ${pos}%`;
+                    }
+                    break;
+                }
+                case 'scale': {
+                    const scale = 1 + Math.sin(offset * 0.01) * 0.1;
+                    el.style.transform = `scale(${scale.toFixed(3)})`;
+                    break;
+                }
+                default:
+                    break;
+            }
+        });
+    }, { autoStart: true });
+}
diff --git a/resources/js/modules/scroll-timeline/index.js b/resources/js/modules/scroll-timeline/index.js
new file mode 100644
index 00000000..ec62ad57
--- /dev/null
+++ b/resources/js/modules/scroll-timeline/index.js
@@ -0,0 +1,53 @@
+// modules/scroll-timeline/index.js
+import { Logger } from '../../core/logger.js';
+import { scrollSteps } from './steps.js';
+import {registerFrameTask, unregisterFrameTask} from '../../core/frameloop.js';
+
+export function init(userConfig = {}) {
+    Logger.info('ScrollTimeline init');
+
+    const defaultConfig = {
+        attribute: 'data-scroll-step',
+        triggerPoint: 0.4,
+        once: true
+    };
+
+    const config = { ...defaultConfig, ...userConfig };
+
+    const steps = Array.from(document.querySelectorAll(`[${config.attribute}]`)).map(el => ({
+        el,
+        index: parseInt(el.getAttribute(config.attribute), 10),
+        active: false
+    }));
+
+    function update() {
+        const triggerY = window.innerHeight * config.triggerPoint;
+
+        steps.forEach(step => {
+            const rect = step.el.getBoundingClientRect();
+            const isVisible = rect.top < triggerY && rect.bottom > 0;
+
+            if (isVisible && !step.active) {
+                step.active = true;
+                step.el.classList.add('active');
+                Logger.log(`➡️ ENTER step ${step.index}`);
+                scrollSteps.onEnter?.(step.index, step.el);
+            }
+
+            if (!isVisible && step.active) {
+                step.active = false;
+                step.el.classList.remove('active');
+                Logger.log(`⬅️ LEAVE step ${step.index}`);
+                if (!config.once) {
+                    scrollSteps.onLeave?.(step.index, step.el);
+                }
+            }
+        });
+    }
+
+    registerFrameTask('scroll-timeline', update, { autoStart: true });
+}
+
+export function destroy () {
+    unregisterFrameTask('scroll-timeline');
+}
diff --git a/resources/js/modules/scroll-timeline/steps.js b/resources/js/modules/scroll-timeline/steps.js
new file mode 100644
index 00000000..526acf87
--- /dev/null
+++ b/resources/js/modules/scroll-timeline/steps.js
@@ -0,0 +1,33 @@
+export const scrollSteps = {
+    onEnter(index, el) {
+        el.classList.add('active');
+        document.body.dataset.activeScrollStep = index;
+        console.log(`[ScrollStep] Enter: ${index}`);
+        // Beispielaktionen
+        if (index === 1) showIntro();
+        if (index === 2) activateChart();
+        if (index === 3) revealQuote();
+    },
+
+    onLeave(index, el) {
+        el.classList.remove('active');
+        el.style.transitionDelay = '';
+        console.log(`[ScrollStep] Leave: ${index}`);
+
+        if (document.body.dataset.activeScrollStep === String(index)) {
+            delete document.body.dataset.activeScrollStep;
+        }
+
+        if (index === 1) hideIntro();
+        if (index === 2) deactivateChart();
+        if (index === 3) hideQuote();
+    }
+};
+
+
+function showIntro()   { console.log('Intro sichtbar'); }
+function hideIntro()   { console.log('Intro ausgeblendet'); }
+function activateChart() { console.log('Chart aktiviert'); }
+function deactivateChart() { console.log('Chart deaktiviert'); }
+function revealQuote() { console.log('Zitat eingeblendet'); }
+function hideQuote()   { console.log('Zitat ausgeblendet'); }
diff --git a/resources/js/modules/scrollfx/ScrollEngine.js b/resources/js/modules/scrollfx/ScrollEngine.js
new file mode 100644
index 00000000..99f6a621
--- /dev/null
+++ b/resources/js/modules/scrollfx/ScrollEngine.js
@@ -0,0 +1,36 @@
+// src/resources/js/scrollfx/ScrollEngine.js
+
+class ScrollEngine {
+    constructor() {
+        this.triggers = new Set();
+        this.viewportHeight = window.innerHeight;
+        this._loop = this._loop.bind(this);
+
+        window.addEventListener('resize', () => {
+            this.viewportHeight = window.innerHeight;
+        });
+
+        requestAnimationFrame(this._loop);
+    }
+
+    register(trigger) {
+        this.triggers.add(trigger);
+    }
+
+    unregister(trigger) {
+        this.triggers.delete(trigger);
+    }
+
+    clear() {
+        this.triggers.clear();
+    }
+
+    _loop() {
+        this.triggers.forEach(trigger => {
+            trigger.update(this.viewportHeight);
+        });
+        requestAnimationFrame(this._loop);
+    }
+}
+
+export default new ScrollEngine();
diff --git a/resources/js/modules/scrollfx/ScrollTrigger.js b/resources/js/modules/scrollfx/ScrollTrigger.js
new file mode 100644
index 00000000..b8bbd57a
--- /dev/null
+++ b/resources/js/modules/scrollfx/ScrollTrigger.js
@@ -0,0 +1,69 @@
+// src/resources/js/scrollfx/ScrollTrigger.js
+
+export default class ScrollTrigger {
+    constructor(config) {
+        this.element = this.resolveElement(config.element);
+        this.target = config.target
+            ? this.element.querySelector(config.target)
+            : this.element;
+
+        if (config.target && !this.target) {
+            throw new Error(`Target selector '${config.target}' not found inside element '${config.element}'.`);
+        }
+
+        this.start = config.start || 'top 80%';
+        this.end = config.end || 'bottom 20%';
+        this.scrub = config.scrub || false;
+        this.onEnter = config.onEnter || null;
+        this.onLeave = config.onLeave || null;
+        this.onUpdate = config.onUpdate || null;
+
+        this._wasVisible = false;
+        this._progress = 0;
+    }
+
+    resolveElement(input) {
+        if (typeof input === 'string') {
+            const els = document.querySelectorAll(input);
+            if (els.length === 1) return els[0];
+            throw new Error(`Selector '${input}' matched ${els.length} elements, expected exactly 1.`);
+        }
+        return input;
+    }
+
+    getScrollProgress(viewportHeight) {
+        const rect = this.element.getBoundingClientRect();
+        const startPx = this.parsePosition(this.start, viewportHeight);
+        const endPx = this.parsePosition(this.end, viewportHeight);
+        const scrollRange = endPx - startPx;
+        const current = rect.top - startPx;
+        return 1 - Math.min(Math.max(current / scrollRange, 0), 1);
+    }
+
+    parsePosition(pos, viewportHeight) {
+        const [edge, value] = pos.split(' ');
+        const edgeOffset = edge === 'top' ? 0 : viewportHeight;
+        const percentage = parseFloat(value) / 100;
+        return edgeOffset - viewportHeight * percentage;
+    }
+
+    update(viewportHeight) {
+        const rect = this.element.getBoundingClientRect();
+        const inViewport = rect.bottom > 0 && rect.top < viewportHeight;
+
+        if (inViewport && !this._wasVisible) {
+            this._wasVisible = true;
+            if (this.onEnter) this.onEnter(this.target);
+        }
+
+        if (!inViewport && this._wasVisible) {
+            this._wasVisible = false;
+            if (this.onLeave) this.onLeave(this.target);
+        }
+
+        if (this.scrub && inViewport) {
+            const progress = this.getScrollProgress(viewportHeight);
+            if (this.onUpdate) this.onUpdate(this.target, progress);
+        }
+    }
+}
diff --git a/resources/js/modules/scrollfx/Tween.js b/resources/js/modules/scrollfx/Tween.js
new file mode 100644
index 00000000..75f6ad95
--- /dev/null
+++ b/resources/js/modules/scrollfx/Tween.js
@@ -0,0 +1,177 @@
+// resources/js/scrollfx/Tween.js
+
+export const Easing = {
+    linear: t => t,
+    easeInQuad: t => t * t,
+    easeOutQuad: t => t * (2 - t),
+    easeInOutQuad: t => (t < 0.5 ? 2 * t * t : -1 + (4 - 2 * t) * t),
+};
+
+function interpolate(start, end, t) {
+    return start + (end - start) * t;
+}
+
+function parseTransform(transform) {
+    const result = {
+        translateY: 0,
+        scale: 1,
+        rotate: 0
+    };
+    if (!transform || transform === 'none') return result;
+
+    const translateMatch = transform.match(/translateY\((-?\d+(?:\.\d+)?)px\)/);
+    const scaleMatch = transform.match(/scale\((-?\d+(?:\.\d+)?)\)/);
+    const rotateMatch = transform.match(/rotate\((-?\d+(?:\.\d+)?)deg\)/);
+
+    if (translateMatch) result.translateY = parseFloat(translateMatch[1]);
+    if (scaleMatch) result.scale = parseFloat(scaleMatch[1]);
+    if (rotateMatch) result.rotate = parseFloat(rotateMatch[1]);
+
+    return result;
+}
+
+export function tweenTo(el, props = {}, duration = 300, easing = Easing.linear) {
+    const start = performance.now();
+    const initial = {};
+
+    const currentTransform = parseTransform(getComputedStyle(el).transform);
+
+    for (const key in props) {
+        if (['translateY', 'scale', 'rotate'].includes(key)) {
+            initial[key] = currentTransform[key];
+        } else {
+            const current = parseFloat(getComputedStyle(el)[key]) || 0;
+            initial[key] = current;
+        }
+    }
+
+    function animate(now) {
+        const t = Math.min((now - start) / duration, 1);
+        const eased = easing(t);
+
+        let transformParts = [];
+
+        for (const key in props) {
+            const startValue = initial[key];
+            const endValue = parseFloat(props[key]);
+            const current = interpolate(startValue, endValue, eased);
+
+            if (key === 'translateY') transformParts.push(`translateY(${current}px)`);
+            else if (key === 'scale') transformParts.push(`scale(${current})`);
+            else if (key === 'rotate') transformParts.push(`rotate(${current}deg)`);
+            else el.style[key] = current + (key === 'opacity' ? '' : 'px');
+        }
+
+        if (transformParts.length > 0) {
+            el.style.transform = transformParts.join(' ');
+        }
+
+        if (t < 1) requestAnimationFrame(animate);
+    }
+
+    requestAnimationFrame(animate);
+}
+
+export function timeline(steps = []) {
+    let index = 0;
+
+    function runNext() {
+        if (index >= steps.length) return;
+        const { el, props, duration, easing = Easing.linear, delay = 0 } = steps[index++];
+        setTimeout(() => {
+            tweenTo(el, props, duration, easing);
+            setTimeout(runNext, duration);
+        }, delay);
+    }
+
+    runNext();
+}
+
+export function tweenFromTo(el, from = {}, to = {}, duration = 300, easing = Easing.linear) {
+    for (const key in from) {
+        if (['translateY', 'scale', 'rotate'].includes(key)) {
+            el.style.transform = `${key}(${from[key]}${key === 'rotate' ? 'deg' : key === 'translateY' ? 'px' : ''})`;
+        } else {
+            el.style[key] = from[key] + (key === 'opacity' ? '' : 'px');
+        }
+    }
+    tweenTo(el, to, duration, easing);
+}
+
+// === Utility Animations ===
+
+export function fadeIn(el, duration = 400, easing = Easing.easeOutQuad) {
+    el.classList.remove('fade-out');
+    el.classList.add('fade-in');
+    tweenTo(el, { opacity: 1 }, duration, easing);
+}
+
+export function fadeOut(el, duration = 400, easing = Easing.easeInQuad) {
+    el.classList.remove('fade-in');
+    el.classList.add('fade-out');
+    tweenTo(el, { opacity: 0 }, duration, easing);
+}
+
+export function zoomIn(el, duration = 500, easing = Easing.easeOutQuad) {
+    el.classList.add('zoom-in');
+    tweenTo(el, { opacity: 1, scale: 1 }, duration, easing);
+}
+
+export function zoomOut(el, duration = 500, easing = Easing.easeInQuad) {
+    el.classList.remove('zoom-in');
+    tweenTo(el, { opacity: 0, scale: 0.8 }, duration, easing);
+}
+
+export function triggerCssAnimation(el, className, duration = 1000) {
+    el.classList.add(className);
+    setTimeout(() => {
+        el.classList.remove(className);
+    }, duration);
+}
+
+// === ScrollTrigger Presets ===
+
+import { createTrigger } from './index.js';
+
+export function fadeScrollTrigger(selector, options = {}) {
+    const elements = document.querySelectorAll(selector);
+    elements.forEach(el => {
+        createTrigger({
+            element: el,
+            start: options.start || 'top 80%',
+            end: options.end || 'bottom 20%',
+            onEnter: () => fadeIn(el),
+            onLeave: () => fadeOut(el)
+        });
+    });
+}
+
+export function zoomScrollTrigger(selector, options = {}) {
+    const elements = document.querySelectorAll(selector);
+    elements.forEach(el => {
+        createTrigger({
+            element: el,
+            start: options.start || 'top 80%',
+            end: options.end || 'bottom 20%',
+            onEnter: () => zoomIn(el),
+            onLeave: () => zoomOut(el)
+        });
+    });
+}
+
+export function fixedZoomScrollTrigger(selector, options = {}) {
+    const elements = document.querySelectorAll(selector);
+    elements.forEach(el => {
+        el.style.willChange = 'transform, opacity';
+        el.style.opacity = 0;
+        el.style.transform = 'scale(0.8)';
+
+        createTrigger({
+            element: el,
+            start: options.start || 'top 100%',
+            end: options.end || 'top 40%',
+            onEnter: () => zoomIn(el, 600),
+            onLeave: () => zoomOut(el, 400)
+        });
+    });
+}
diff --git a/resources/js/modules/scrollfx/index.js b/resources/js/modules/scrollfx/index.js
new file mode 100644
index 00000000..a06cf66b
--- /dev/null
+++ b/resources/js/modules/scrollfx/index.js
@@ -0,0 +1,57 @@
+// src/resources/js/scrollfx/index.js
+
+import ScrollEngine from './ScrollEngine.js';
+import ScrollTrigger from './ScrollTrigger.js';
+import {fadeScrollTrigger, fixedZoomScrollTrigger, zoomScrollTrigger} from "./Tween";
+
+export function createTrigger(config) {
+    const elements = typeof config.element === 'string'
+        ? document.querySelectorAll(config.element)
+        : [config.element];
+
+    const triggers = [];
+
+    elements.forEach(el => {
+        const trigger = new ScrollTrigger({ ...config, element: el });
+        ScrollEngine.register(trigger);
+        triggers.push(trigger);
+    });
+
+    return triggers.length === 1 ? triggers[0] : triggers;
+}
+
+export function init(config = {}) {
+    const {
+        selector = '.fade-in-on-scroll, .zoom-in, .fade-out, .fade',
+        offset = 0.85,        // z.B. 85 % Viewport-Höhe
+        baseDelay = 0.05,     // delay pro Element (stagger)
+        once = true           // nur 1× triggern?
+    } = config;
+
+    const elements = Array.from(document.querySelectorAll(selector))
+        .map(el => ({ el, triggered: false }));
+
+    function update() {
+        const triggerY = window.innerHeight * offset;
+
+        elements.forEach((obj, index) => {
+            if (obj.triggered && once) return;
+
+            const rect = obj.el.getBoundingClientRect();
+
+            if (rect.top < triggerY) {
+                obj.el.style.transitionDelay = `${index * baseDelay}s`;
+                obj.el.classList.add('visible', 'entered');
+                obj.el.classList.remove('fade-out');
+                obj.triggered = true;
+            } else if (!once) {
+                obj.el.classList.remove('visible', 'entered');
+                obj.triggered = false;
+            }
+        });
+
+        requestAnimationFrame(update);
+    }
+
+    requestAnimationFrame(update);
+}
diff --git a/resources/js/modules/sidebar/index.js b/resources/js/modules/sidebar/index.js
new file mode 100644
index 00000000..0a364443
--- /dev/null
+++ b/resources/js/modules/sidebar/index.js
@@ -0,0 +1,62 @@
+import {useEvent} from "../../core";
+import {removeModules} from "../../core/removeModules";
+
+let keydownHandler = null;
+let clickHandler = null;
+
+export function init() {
+    const el = document.getElementById("sidebar-menu");
+    const button = document.getElementById('menu-toggle');
+    const aside = document.getElementById('sidebar');
+    const backdrop = document.querySelector('.backdrop');
+
+    const footer = document.querySelector('footer');
+    const headerLink = document.querySelector('header a');
+
+
+    useEvent(button, 'click', (e) => {
+        aside.classList.toggle('show');
+        //aside.toggleAttribute('inert')
+
+        let isVisible = aside.classList.contains('show');
+
+        if (isVisible) {
+            backdrop.classList.add('visible');
+
+            footer.setAttribute('inert', 'true');
+            headerLink.setAttribute('inert', 'true');
+        } else {
+            backdrop.classList.remove('visible');
+
+            footer.removeAttribute('inert');
+            headerLink.removeAttribute('inert');
+        }
+    })
+
+    keydownHandler = (e) => {
+        if(e.key === 'Escape'){
+            if(aside.classList.contains('show')){
+                aside.classList.remove('show');
+                backdrop.classList.remove('visible');
+            }
+        }
+    }
+
+    useEvent(document, 'keydown', keydownHandler)
+
+    clickHandler = (e) => {
+        aside.classList.remove('show');
+        backdrop.classList.remove('visible');
+
+        footer.removeAttribute('inert');
+        headerLink.removeAttribute('inert');
+    }
+
+    useEvent(backdrop, 'click' , clickHandler)
+}
+
+export function destroy() {
+    /*document.removeEventListener('keydown', keydownHandler);
+    document.removeEventListener('click', clickHandler);*/
+    removeModules('sidebar');
+}
diff --git a/resources/js/modules/smooth-scroll/index.js b/resources/js/modules/smooth-scroll/index.js
new file mode 100644
index 00000000..1cc22862
--- /dev/null
+++ b/resources/js/modules/smooth-scroll/index.js
@@ -0,0 +1,118 @@
+// modules/smooth-scroll/index.js
+import { Logger } from '../../core/logger.js';
+import { registerFrameTask } from '../../core/frameloop.js';
+
+/*
+export function init(config = {}) {
+    Logger.info('SmoothScroll init');
+
+    const defaultConfig = {
+        speed: 0.12,
+        scrollTarget: window,
+        interceptWheel: true,
+        interceptTouch: true,
+        interceptKeys: true
+    };
+
+    const settings = { ...defaultConfig, ...config };
+    const scrollElement = settings.scrollTarget === window ? document.scrollingElement : settings.scrollTarget;
+
+    let current = scrollElement.scrollTop;
+    let target = current;
+
+    function clampTarget() {
+        const maxScroll = scrollElement.scrollHeight - window.innerHeight;
+        target = Math.max(0, Math.min(target, maxScroll));
+    }
+
+    function update() {
+        const delta = target - current;
+        current += delta * settings.speed;
+
+        const maxScroll = scrollElement.scrollHeight - window.innerHeight;
+        current = Math.max(0, Math.min(current, maxScroll));
+
+        scrollElement.scrollTop = current;
+    }
+
+    registerFrameTask('smooth-scroll', update, { autoStart: true });
+
+    function triggerScroll(immediate = false) {
+        clampTarget();
+        if (immediate) scrollElement.scrollTop = target;
+    }
+
+    function onWheel(e) {
+        if (!settings.interceptWheel) return;
+        e.preventDefault();
+        target += e.deltaY;
+        triggerScroll(true);
+    }
+
+    let lastTouchY = 0;
+
+    function onTouchStart(e) {
+        if (!settings.interceptTouch) return;
+        lastTouchY = e.touches[0].clientY;
+    }
+
+    function onTouchMove(e) {
+        if (!settings.interceptTouch) return;
+        e.preventDefault();
+        const touch = e.changedTouches[0];
+        const dy = lastTouchY - touch.clientY;
+        target += dy;
+        lastTouchY = touch.clientY;
+        triggerScroll(true);
+    }
+
+    function onKeyDown(e) {
+        if (!settings.interceptKeys) return;
+        const keyScrollAmount = 60;
+        switch (e.key) {
+            case 'ArrowDown':
+                e.preventDefault();
+                target += keyScrollAmount;
+                break;
+            case 'ArrowUp':
+                e.preventDefault();
+                target -= keyScrollAmount;
+                break;
+            case 'PageDown':
+                e.preventDefault();
+                target += window.innerHeight * 0.9;
+                break;
+            case 'PageUp':
+                e.preventDefault();
+                target -= window.innerHeight * 0.9;
+                break;
+            case 'Home':
+                e.preventDefault();
+                target = 0;
+                break;
+            case 'End':
+                e.preventDefault();
+                target = scrollElement.scrollHeight;
+                break;
+        }
+        triggerScroll(true);
+    }
+
+    if (settings.interceptWheel) {
+        window.addEventListener('wheel', onWheel, { passive: false });
+    }
+
+    if (settings.interceptTouch) {
+        window.addEventListener('touchstart', onTouchStart, { passive: false });
+        window.addEventListener('touchmove', onTouchMove, { passive: false });
+    }
+
+    if (settings.interceptKeys) {
+        window.addEventListener('keydown', onKeyDown);
+    }
+
+    // initial scroll alignment
+    target = scrollElement.scrollTop;
+    current = target;
+}
+*/
diff --git a/resources/js/modules/sticky-fade/index.js b/resources/js/modules/sticky-fade/index.js
new file mode 100644
index 00000000..6cc8ca01
--- /dev/null
+++ b/resources/js/modules/sticky-fade/index.js
@@ -0,0 +1,67 @@
+// modules/sticky-fade/index.js
+import { registerFrameTask, unregisterFrameTask } from '../../core/frameloop.js';
+
+let taskId = 'sticky-fade';
+let elements = [];
+let lastScrollY = window.scrollY;
+let activeMap = new WeakMap();
+let configCache = {
+    direction: false,
+    reset: false,
+};
+
+
+export function init(config = {}) {
+    elements = Array.from(document.querySelectorAll('[data-sticky-fade]'));
+    if (elements.length === 0) return;
+
+    configCache.direction = config.direction ?? false;
+    configCache.reset = config.reset ?? false;
+
+    registerFrameTask(taskId, () => {
+        const scrollY = window.scrollY;
+        const direction = scrollY > lastScrollY ? 'down' : scrollY < lastScrollY ? 'up' : 'none';
+        lastScrollY = scrollY;
+
+        const viewportHeight = window.innerHeight;
+
+        elements.forEach(el => {
+            const rect = el.getBoundingClientRect();
+            const progress = 1 - Math.min(Math.max(rect.top / viewportHeight, 0), 1);
+
+            el.style.opacity = progress.toFixed(3);
+            el.style.transform = `translateY(${(1 - progress) * 20}px)`;
+
+            if(configCache.direction) {
+                el.dataset.scrollDir = direction;
+            }
+
+            if (configCache.reset) {
+                const isVisible = progress >= 1;
+                const wasActive = activeMap.get(el) || false;
+
+                if(isVisible && !wasActive) {
+                    el.classList.add('visible');
+                    activeMap.set(el, true);
+                } else if(!isVisible && wasActive) {
+                    el.classList.remove('visible');
+                    activeMap.set(el, false);
+                }
+            }
+        });
+    }, { autoStart: true });
+}
+
+export function destroy() {
+    unregisterFrameTask(taskId);
+
+    elements.forEach(el => {
+        el.style.opacity = '';
+        el.style.transform = '';
+        el.classList.remove('visible');
+        delete el.dataset.scrollDir;
+    });
+
+    elements = [];
+    activeMap = new WeakMap();
+}
diff --git a/resources/js/modules/sticky-steps/index.js b/resources/js/modules/sticky-steps/index.js
new file mode 100644
index 00000000..09118e8f
--- /dev/null
+++ b/resources/js/modules/sticky-steps/index.js
@@ -0,0 +1,45 @@
+// modules/sticky-steps/index.js
+import { Logger } from '../../core/logger.js';
+import {registerFrameTask, unregisterFrameTask} from '../../core/frameloop.js';
+
+export function init(config = {}) {
+    Logger.info('StickySteps init');
+
+    const defaultConfig = {
+        containerSelector: '[data-sticky-container]',
+        stepSelector: '[data-sticky-step]',
+        activeClass: 'is-sticky-active',
+        datasetKey: 'activeStickyStep'
+    };
+
+    const settings = { ...defaultConfig, ...config };
+    const containers = document.querySelectorAll(settings.containerSelector);
+
+    containers.forEach(container => {
+        const steps = container.querySelectorAll(settings.stepSelector);
+        const containerOffsetTop = container.offsetTop;
+
+        function update() {
+            const scrollY = window.scrollY;
+            const containerHeight = container.offsetHeight;
+
+            steps.forEach((step, index) => {
+                const stepOffset = containerOffsetTop + index * (containerHeight / steps.length);
+                const nextStepOffset = containerOffsetTop + (index + 1) * (containerHeight / steps.length);
+
+                const isActive = scrollY >= stepOffset && scrollY < nextStepOffset;
+                step.classList.toggle(settings.activeClass, isActive);
+
+                if (isActive) {
+                    container.dataset[settings.datasetKey] = index;
+                }
+            });
+        }
+
+        registerFrameTask(`sticky-steps-${container.dataset.moduleId || Math.random()}`, update, { autoStart: true });
+    });
+}
+
+export function destroy() {
+    unregisterFrameTask('sticky-steps');
+}
diff --git a/resources/js/modules/ui/UIManager.js b/resources/js/modules/ui/UIManager.js
new file mode 100644
index 00000000..283ccd42
--- /dev/null
+++ b/resources/js/modules/ui/UIManager.js
@@ -0,0 +1,23 @@
+// modules/ui/UIManager.js
+import { Modal } from './components/Modal.js';
+
+const components = {
+    modal: Modal,
+};
+
+export const UIManager = {
+    open(type, props = {}) {
+        const Component = components[type];
+        if (!Component) {
+            console.warn(`[UIManager] Unknown type: ${type}`);
+            return null;
+        }
+        const instance = new Component(props);
+        instance.open();
+        return instance;
+    },
+
+    close(instance) {
+        if (instance?.close) instance.close();
+    }
+};
diff --git a/resources/js/modules/ui/components/Dialog.js b/resources/js/modules/ui/components/Dialog.js
new file mode 100644
index 00000000..10bbf00b
--- /dev/null
+++ b/resources/js/modules/ui/components/Dialog.js
@@ -0,0 +1,41 @@
+import {useEvent} from "../../../core/useEvent";
+
+export class Dialog {
+    constructor({content = '', className = '', onClose = null} = {}) {
+        this.onClose = onClose;
+        this.dialog = document.createElement('dialog');
+        this.dialog.className = className;
+        this.dialog.innerHTML = `
+      <form method="dialog" class="${className}-content">
+        ${content}
+        <button class="${className}-close" value="close">×</button>
+      </form>
+    `;
+
+        useEvent(this.dialog, 'click', (e) => {
+            const isOutside = !e.target.closest(className+'-content');
+            if (isOutside) this.close();
+        })
+
+        useEvent(this.dialog, 'cancel', (e) => {
+            e.preventDefault();
+            this.close();
+        })
+
+    }
+
+    open()
+    {
+        document.body.appendChild(this.dialog);
+        this.dialog.showModal?.() || this.dialog.setAttribute('open', '');
+        document.documentElement.dataset[`${this.dialog.className}Open`] = 'true';
+    }
+
+    close()
+    {
+        this.dialog.close?.() || this.dialog.removeAttribute('open');
+        this.dialog.remove();
+        delete document.documentElement.dataset[`${this.dialog.className}Open`];
+        this.onClose?.();
+    }
+}
diff --git a/resources/js/modules/ui/components/Lightbox.js b/resources/js/modules/ui/components/Lightbox.js
new file mode 100644
index 00000000..0e0303e6
--- /dev/null
+++ b/resources/js/modules/ui/components/Lightbox.js
@@ -0,0 +1,6 @@
+import { Dialog } from './Dialog.js';
+export class Lightbox extends Dialog {
+    constructor(props) {
+        super({ ...props, className: 'lightbox' });
+    }
+}
diff --git a/resources/js/modules/ui/components/Modal.js b/resources/js/modules/ui/components/Modal.js
new file mode 100644
index 00000000..3b6d4676
--- /dev/null
+++ b/resources/js/modules/ui/components/Modal.js
@@ -0,0 +1,6 @@
+import { Dialog } from './Dialog.js';
+export class Modal extends Dialog {
+    constructor(props) {
+        super({ ...props, className: 'modal' });
+    }
+}
diff --git a/resources/js/modules/ui/index.js b/resources/js/modules/ui/index.js
new file mode 100644
index 00000000..656b7942
--- /dev/null
+++ b/resources/js/modules/ui/index.js
@@ -0,0 +1,9 @@
+import { UIManager } from './UIManager.js';
+
+export function init() {
+
+    /*UIManager.open('modal', {
+        content: '<p>Hallo!</p><button class="modal-close">OK</button>',
+        onClose: () => console.log('Modal wurde geschlossen')
+    });*/
+}
diff --git a/resources/js/modules/wheel-boost/index.js b/resources/js/modules/wheel-boost/index.js
new file mode 100644
index 00000000..a0fea810
--- /dev/null
+++ b/resources/js/modules/wheel-boost/index.js
@@ -0,0 +1,40 @@
+// modules/wheel-boost/index.js
+import { registerFrameTask, unregisterFrameTask } from '../../core/frameloop.js';
+
+/*
+let velocity = 0;
+let taskId = 'wheel-boost';
+let damping = 0.85;
+let boost = 1.2;
+let enabled = true;
+
+export function init(config = {}) {
+    damping = typeof config.damping === 'number' ? config.damping : 0.85;
+    boost = typeof config.boost === 'number' ? config.boost : 1.2;
+    enabled = config.enabled !== false;
+
+    if (!enabled) return;
+
+    window.addEventListener('wheel', onWheel, { passive: false });
+
+    registerFrameTask(taskId, () => {
+        if (Math.abs(velocity) > 0.1) {
+            window.scrollBy(0, velocity);
+            velocity *= damping;
+        } else {
+            velocity = 0;
+        }
+    }, { autoStart: true });
+}
+
+function onWheel(e) {
+    velocity += e.deltaY * boost;
+    e.preventDefault(); // verhindert das native Scrollen
+}
+
+export function destroy() {
+    window.removeEventListener('wheel', onWheel);
+    unregisterFrameTask(taskId);
+    velocity = 0;
+}
+*/
diff --git a/resources/js/serviceWorker.js b/resources/js/serviceWorker.js
new file mode 100644
index 00000000..181efcb8
--- /dev/null
+++ b/resources/js/serviceWorker.js
@@ -0,0 +1,23 @@
+export function registerServiceWorker() {
+    if ('serviceWorker' in navigator) {
+        navigator.serviceWorker.register('/sw.js')
+            .then(reg => {
+                console.log('✅ Service Worker registriert:', reg.scope);
+
+                // Update found?
+                reg.onupdatefound = () => {
+                    const installing = reg.installing;
+                    installing.onstatechange = () => {
+                        if (installing.state === 'installed') {
+                            if (navigator.serviceWorker.controller) {
+                                console.log('🔄 Neue Version verfügbar – Seite neu laden?');
+                            } else {
+                                console.log('✅ Inhalte jetzt offline verfügbar');
+                            }
+                        }
+                    };
+                };
+            })
+            .catch(err => console.error('❌ SW-Fehler:', err));
+    }
+}
diff --git a/resources/js/utils/autoLoadResponsiveVideo.js b/resources/js/utils/autoLoadResponsiveVideo.js
new file mode 100644
index 00000000..38993eab
--- /dev/null
+++ b/resources/js/utils/autoLoadResponsiveVideo.js
@@ -0,0 +1,50 @@
+// 📦 Automatischer Video-Loader (Bandbreiten- & Auflösungs-bewusst)
+// Erkennt automatisch <video data-src="basename"> Elemente
+// Lädt passende Variante: basename-480.webm, -720.webm, -1080.webm etc.
+
+export function autoLoadResponsiveVideos() {
+    const videos = document.querySelectorAll('video[data-src]');
+    const width = window.innerWidth;
+    const connection = navigator.connection || {};
+    const net = connection.effectiveType || '4g';
+
+    videos.forEach(video => {
+        const base = video.dataset.src;
+        let suffix = '480';
+
+        if (net === '2g' || net === 'slow-2g') {
+            suffix = '480';
+        } else if (net === '3g') {
+            suffix = width >= 1200 ? '720' : '480';
+        } else {
+            suffix = width >= 1200 ? '1080' : width >= 800 ? '720' : '480';
+        }
+
+        const src = `${base}-${suffix}.webm`;
+
+        const newVideo = document.createElement('video');
+        newVideo.autoplay = true;
+        newVideo.loop = true;
+        newVideo.muted = true;
+        newVideo.playsInline = true;
+        newVideo.poster = video.getAttribute('poster') || '';
+        newVideo.setAttribute('width', video.getAttribute('width') || '100%');
+
+        const source = document.createElement('source');
+        source.src = src;
+        source.type = 'video/webm';
+
+        newVideo.appendChild(source);
+        video.replaceWith(newVideo);
+    });
+}
+
+/*
+
+
+<video data-src="/media/video" poster="/media/preview.jpg" width="100%">
+    <!-- Optionaler Fallback -->
+    <source src="/media/video-480.mp4" type="video/mp4"/>
+</video>
+
+*/
diff --git a/resources/js/utils/cache.js b/resources/js/utils/cache.js
new file mode 100644
index 00000000..6795b1b9
--- /dev/null
+++ b/resources/js/utils/cache.js
@@ -0,0 +1,34 @@
+export class SimpleCache {
+    constructor(maxSize = 20, ttl = 60000) {
+        this.cache = new Map();
+        this.maxSize = maxSize;
+        this.ttl = ttl;
+    }
+
+    get(key) {
+        const cached = this.cache.get(key);
+        if (!cached) return null;
+        if (Date.now() - cached.timestamp > this.ttl) {
+            this.cache.delete(key);
+            return null;
+        }
+        return cached.data;
+    }
+
+    set(key, data) {
+        if (this.cache.size >= this.maxSize) {
+            // Entferne das älteste Element
+            const oldest = [...this.cache.entries()].sort((a, b) => a[1].timestamp - b[1].timestamp)[0][0];
+            this.cache.delete(oldest);
+        }
+        this.cache.set(key, { data, timestamp: Date.now() });
+    }
+
+    has(key) {
+        return this.get(key) !== null;
+    }
+
+    clear() {
+        this.cache.clear();
+    }
+}
diff --git a/resources/js/utils/index.js b/resources/js/utils/index.js
new file mode 100644
index 00000000..79b51282
--- /dev/null
+++ b/resources/js/utils/index.js
@@ -0,0 +1 @@
+export * from './cache'
diff --git a/scripts/fix-worker-permissions.sh b/scripts/fix-worker-permissions.sh
new file mode 100644
index 00000000..f64f040b
--- /dev/null
+++ b/scripts/fix-worker-permissions.sh
@@ -0,0 +1,26 @@
+#!/bin/bash
+
+echo "🔧 Fixing worker permissions..."
+
+# Create directories if they don't exist
+#mkdir -p ./storage/logs
+#mkdir -p ./storage/cache
+#mkdir -p ./src/Framework/CommandBus/storage/queue
+
+# Host-System Permissions korrigieren
+echo "📁 Fixing host permissions..."
+chmod -R 775 ../storage/ 2>/dev/null || true
+chmod -R 775 ../src/Framework/CommandBus/storage/ 2>/dev/null || true
+
+echo "✅ Host permissions fixed"
+
+echo "🐳 Restarting worker container..."
+docker-compose restart queue-worker
+
+echo "⏱️  Waiting for worker to start..."
+sleep 3
+
+echo "📋 Worker logs:"
+docker-compose logs --tail=20 queue-worker
+
+echo "✅ Worker restarted successfully!"
diff --git a/scripts/process-performance-logs.php b/scripts/process-performance-logs.php
new file mode 100644
index 00000000..523d7483
--- /dev/null
+++ b/scripts/process-performance-logs.php
@@ -0,0 +1,77 @@
+#!/usr/bin/env php
+<?php
+
+declare(strict_types=1);
+
+require_once __DIR__ . '/../vendor/autoload.php';
+
+use App\Framework\Core\Container;
+use App\Framework\Performance\PerformanceDatabaseWorker;
+use Pest\Support\Container;
+
+$lockFile = sys_get_temp_dir() . '/performance_processing.lock';
+
+// Lock-File prüfen um Doppelausführung zu verhindern
+if (file_exists($lockFile)) {
+    $lockTime = filemtime($lockFile);
+    if (time() - $lockTime < 300) { // 5 Minuten Timeout
+        echo "Performance log processing already running\n";
+        exit(1);
+    }
+    // Altes Lock entfernen
+    unlink($lockFile);
+}
+
+// Lock setzen
+touch($lockFile);
+
+try {
+    $container = new Container();
+    $worker = $container->get(PerformanceDatabaseWorker::class);
+
+    $logFile = $argv[1] ?? null;
+
+    if ($logFile && file_exists($logFile)) {
+        echo "Processing specific log file: {$logFile}\n";
+        $worker->processLogFile($logFile);
+        echo "Processing completed\n";
+    } else {
+        // Alle pending Log-Dateien verarbeiten
+        $logDir = $container->get('paths.storage') . '/logs/performance';
+        $pattern = $logDir . '/performance-*.jsonl';
+        $files = glob($pattern);
+
+        echo "Found " . count($files) . " log files to process\n";
+
+        foreach ($files as $file) {
+            echo "Processing: " . basename($file) . "\n";
+            $worker->processLogFile($file);
+        }
+
+        echo "All files processed\n";
+
+        // Statistiken anzeigen
+        $stats = $worker->getStatistics();
+        if (!empty($stats)) {
+            echo "\nStatistics (last 24h):\n";
+            echo "Total requests: " . $stats['total_logs'] . "\n";
+            echo "Avg response time: " . round($stats['avg_response_time'], 2) . "ms\n";
+            echo "Max response time: " . round($stats['max_response_time'], 2) . "ms\n";
+            echo "Avg memory: " . round($stats['avg_memory'], 2) . "MB\n";
+            echo "Max memory: " . round($stats['max_memory'], 2) . "MB\n";
+        }
+    }
+
+} catch (\Exception $e) {
+    echo "Error: " . $e->getMessage() . "\n";
+    echo $e->getTraceAsString() . "\n";
+    exit(1);
+} finally {
+    // Lock entfernen
+    if (file_exists($lockFile)) {
+        unlink($lockFile);
+    }
+}
+
+echo "Performance log processing completed\n";
+exit(0);
diff --git a/src/Application/Admin/Dashboard.php b/src/Application/Admin/Dashboard.php
new file mode 100644
index 00000000..35784273
--- /dev/null
+++ b/src/Application/Admin/Dashboard.php
@@ -0,0 +1,340 @@
+<?php
+
+namespace App\Application\Admin;
+
+use App\Framework\Attributes\Route;
+use App\Framework\Auth\Auth;
+use App\Framework\Config\TypedConfiguration;
+use App\Framework\Core\VersionInfo;
+use App\Framework\DI\DefaultContainer;
+use App\Framework\Http\HttpResponse;
+use App\Framework\Http\Method;
+use App\Framework\Http\Response;
+use App\Framework\Meta\MetaData;
+use App\Framework\Meta\OpenGraphTypeWebsite;
+use App\Framework\Performance\MemoryUsageTracker;
+use App\Framework\Router\Result\ViewResult;
+use App\Framework\Http\Session\SessionManager;
+use App\Framework\Http\Status;
+use Dom\HTMLDocument;
+
+final readonly class Dashboard
+{
+    public function __construct(
+        private DefaultContainer   $container,
+        private VersionInfo        $versionInfo,
+        private MemoryUsageTracker $memoryTracker,
+        private TypedConfiguration $config,
+    ) {}
+
+    #[Auth]
+    #[Route(path: '/admin', method: Method::GET)]
+    public function show(): ViewResult
+    {
+        $stats = [
+            'frameworkVersion' => $this->versionInfo->getVersion(),
+            'phpVersion' => PHP_VERSION,
+            'memoryUsage' => $this->formatBytes(memory_get_usage(true)),
+            'peakMemoryUsage' => $this->formatBytes(memory_get_peak_usage(true)),
+            'serverInfo' => $_SERVER['SERVER_SOFTWARE'] ?? 'Unknown',
+            'serverTime' => date('Y-m-d H:i:s'),
+            'timezone' => date_default_timezone_get(),
+            'operatingSystem' => PHP_OS,
+            'loadedExtensions' => $this->getLoadedExtensions(),
+            'sessionCount' => $this->getActiveSessionCount(),
+            'uptime' => $this->getServerUptime(),
+            'servicesCount' => 4,#count($this->container->getServiceIds()),
+        ];
+
+        #debug($stats);
+
+        return new ViewResult(
+            template: 'dashboard',
+            metaData: new MetaData('Admin Dashboard'),
+            data: [
+                'title' => 'Admin Dashboard',
+                'stats' => $stats
+            ]
+        );
+    }
+
+    #[Auth]
+    #[Route(path: '/admin/routes', method: Method::GET)]
+    public function routes(): ViewResult
+    {
+        $routeRegistry = $this->container->get('App\Framework\Router\RouteRegistry');
+        $routes = $routeRegistry->getRoutes();
+
+        // Sort routes by path for better readability
+        usort($routes, function($a, $b) {
+            return strcmp($a->path, $b->path);
+        });
+
+        return new ViewResult(
+            template: 'admin/routes',
+            metaData: new MetaData('', ''),
+            data: [
+                'title' => 'Routen-Übersicht',
+                'routes' => $routes
+            ]
+        );
+    }
+
+    #[Auth]
+    #[Route(path: '/admin/services', method: Method::GET)]
+    public function services(): ViewResult
+    {
+        $services = $this->container->getServiceIds();
+        sort($services);
+
+        return new ViewResult(
+            template: 'admin/services',
+            data: [
+                'title' => 'Registrierte Dienste',
+                'services' => $services
+            ]
+        );
+    }
+
+    #[Auth]
+    #[Route(path: '/admin/environment', method: Method::GET)]
+    public function environment(): ViewResult
+    {
+        $env = [];
+        foreach ($_ENV as $key => $value) {
+            // Maskiere sensible Daten
+            if (str_contains(strtolower($key), 'password') ||
+                str_contains(strtolower($key), 'secret') ||
+                str_contains(strtolower($key), 'key')) {
+                $value = '********';
+            }
+            $env[$key] = $value;
+        }
+
+        ksort($env);
+
+        dd($env);
+
+        return new ViewResult(
+            template: 'admin/environment',
+            metaData: new MetaData('', ''),
+            data: [
+                'title' => 'Umgebungsvariablen',
+                'env' => $env
+            ]
+        );
+    }
+
+    #[Auth]
+    #[Route('/admin/phpinfo')]
+    #[Route(path: '/admin/phpinfo/{mode}', method: Method::GET)]
+    public function phpInfo(int $mode = 1): Response
+    {
+        ob_start();
+        phpinfo($mode);
+        $phpinfo = ob_get_clean();
+
+        // Extraktion des <body> Inhalts, um nur den relevanten Teil anzuzeigen
+        preg_match('/<body[^>]*>(.*?)<\/body>/si', $phpinfo, $matches);
+        $body = $matches[1] ?? $phpinfo;
+
+        // Entfernen der Navigation-Links am Anfang
+        #$body = preg_replace('/<div class="center">(.*?)<\/div>/si', '', $body, 1);
+
+        #debug($body);
+
+        // Hinzufügen von eigenen Styles
+        $customStyles = '<style>
+            .phpinfo { font-family: system-ui, sans-serif; line-height: 1.5; }
+            .phpinfo table { border-collapse: collapse; width: 100%; margin-bottom: 1rem; }
+            .phpinfo td, .phpinfo th { padding: 0.5rem; border: 1px solid #ddd; }
+            .phpinfo h1, .phpinfo h2 { margin-bottom: 1rem; }
+            .phpinfo hr { margin: 2rem 0; }
+        </style>';
+
+        $responseBody = '<!DOCTYPE html>
+        <html lang="de">
+        <head>
+            <meta charset="UTF-8">
+            <meta name="viewport" content="width=device-width, initial-scale=1.0">
+            <title>PHP Info</title>
+            <link rel="stylesheet" href="/css/admin.css">
+            ' . $customStyles . '
+        </head>
+        <body class="admin-page">
+            <div class="admin-header">
+                <h1>PHP Info</h1>
+                <a href="/admin" class="btn">Zurück zum Dashboard</a>
+            </div>
+            <div class="admin-content">
+                <div class="phpinfo">' . $body . '</div>
+            </div>
+        </body>
+        </html>';
+
+        echo $responseBody;
+        die();
+
+        return new HttpResponse(status: Status::OK, body: $responseBody);
+    }
+
+    #[Auth]
+    #[Route(path: '/admin/performance', method: Method::GET)]
+    public function performance(): ViewResult
+    {
+        $performanceData = [
+            'currentMemoryUsage' => $this->formatBytes(memory_get_usage(true)),
+            'peakMemoryUsage' => $this->formatBytes(memory_get_peak_usage(true)),
+            'memoryLimit' => $this->formatBytes($this->getMemoryLimitInBytes()),
+            'memoryUsagePercentage' => round((memory_get_usage(true) / $this->getMemoryLimitInBytes()) * 100, 2),
+            'loadAverage' => function_exists('sys_getloadavg') ? sys_getloadavg() : ['N/A', 'N/A', 'N/A'],
+            'opcacheEnabled' => function_exists('opcache_get_status') ? 'Ja' : 'Nein',
+            'executionTime' => number_format(microtime(true) - $_SERVER['REQUEST_TIME_FLOAT'], 4) . ' Sekunden',
+            'includedFiles' => count(get_included_files()),
+        ];
+
+        if (function_exists('opcache_get_status')) {
+            try {
+                $opcacheStatus = opcache_get_status(false);
+                if ($opcacheStatus !== false) {
+                    $performanceData['opcacheMemoryUsage'] = $this->formatBytes($opcacheStatus['memory_usage']['used_memory']);
+                    $performanceData['opcacheCacheHits'] = number_format($opcacheStatus['opcache_statistics']['hits']);
+                    $performanceData['opcacheMissRate'] = number_format($opcacheStatus['opcache_statistics']['misses'] /
+                        ($opcacheStatus['opcache_statistics']['hits'] + $opcacheStatus['opcache_statistics']['misses']) * 100, 2) . '%';
+                }
+            } catch (\Throwable $e) {
+                // OPCache Status konnte nicht abgerufen werden
+                $performanceData['opcacheError'] = $e->getMessage();
+            }
+        }
+
+        return new ViewResult(
+            template: 'performance',
+            data: [
+                'title' => 'Performance-Daten',
+                'performance' => $performanceData
+            ]
+        );
+    }
+
+    #[Auth]
+    #[Route(path: '/admin/redis', method: Method::GET)]
+    public function redisInfo(): ViewResult
+    {
+        $redisInfo = [];
+
+        try {
+            $redis = $this->container->get('Predis\Client');
+            $info = $redis->info();
+            $redisInfo['status'] = 'Verbunden';
+            $redisInfo['version'] = $info['redis_version'];
+            $redisInfo['uptime'] = $this->formatUptime((int)$info['uptime_in_seconds']);
+            $redisInfo['memory'] = $this->formatBytes((int)$info['used_memory']);
+            $redisInfo['peak_memory'] = $this->formatBytes((int)$info['used_memory_peak']);
+            $redisInfo['clients'] = $info['connected_clients'];
+            $redisInfo['keys'] = $redis->dbsize();
+
+            // Einige Schlüssel auflisten (begrenzt auf 50)
+            $keys = $redis->keys('*');
+            $redisInfo['key_sample'] = array_slice($keys, 0, 50);
+        } catch (\Throwable $e) {
+            $redisInfo['status'] = 'Fehler: ' . $e->getMessage();
+        }
+
+        return new ViewResult(
+            template: 'admin/redis',
+            data: [
+                'title' => 'Redis Information',
+                'redis' => $redisInfo
+            ]
+        );
+    }
+
+    private function formatBytes(int $bytes, int $precision = 2): string
+    {
+        $units = ['B', 'KB', 'MB', 'GB', 'TB'];
+
+        $bytes = max($bytes, 0);
+        $pow = floor(($bytes ? log($bytes) : 0) / log(1024));
+        $pow = min($pow, count($units) - 1);
+
+        $bytes /= (1 << (10 * $pow));
+
+        return round($bytes, $precision) . ' ' . $units[$pow];
+    }
+
+    private function getMemoryLimitInBytes(): int
+    {
+        $memoryLimit = ini_get('memory_limit');
+
+        if ($memoryLimit === '-1') {
+            return PHP_INT_MAX;
+        }
+
+        $value = (int) $memoryLimit;
+        $unit = strtolower($memoryLimit[strlen($memoryLimit)-1]);
+
+        switch($unit) {
+            case 'g':
+                $value *= 1024;
+            case 'm':
+                $value *= 1024;
+            case 'k':
+                $value *= 1024;
+                break;
+        }
+
+        return $value;
+    }
+
+    private function getLoadedExtensions(): array
+    {
+        $extensions = get_loaded_extensions();
+        sort($extensions);
+        return $extensions;
+    }
+
+    private function getActiveSessionCount(): int
+    {
+        try {
+            if ($this->container->has(SessionManager::class)) {
+                $sessionManager = $this->container->get(SessionManager::class);
+                // Diese Methode müsste implementiert werden
+                return $sessionManager->getActiveSessionCount();
+            }
+        } catch (\Throwable $e) {
+            // Silent fail
+        }
+
+        return 0;
+    }
+
+    private function getServerUptime(): string
+    {
+        // Für Linux-Systeme
+        if (function_exists('shell_exec') && stripos(PHP_OS, 'Linux') !== false) {
+            $uptime = shell_exec('uptime -p');
+            if ($uptime) {
+                return $uptime;
+            }
+        }
+
+        // Fallback
+        return 'Nicht verfügbar';
+    }
+
+    private function formatUptime(int $seconds): string
+    {
+        $days = floor($seconds / 86400);
+        $hours = floor(($seconds % 86400) / 3600);
+        $minutes = floor(($seconds % 3600) / 60);
+        $remainingSeconds = $seconds % 60;
+
+        $result = '';
+        if ($days > 0) {
+            $result .= "$days Tage, ";
+        }
+
+        return $result . sprintf('%02d:%02d:%02d', $hours, $minutes, $remainingSeconds);
+    }
+}
diff --git a/src/Application/Admin/Images.php b/src/Application/Admin/Images.php
new file mode 100644
index 00000000..9352c308
--- /dev/null
+++ b/src/Application/Admin/Images.php
@@ -0,0 +1,37 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Application\Admin;
+
+use App\Domain\Media\Image;
+use App\Domain\Media\ImageRepository;
+use App\Framework\Attributes\Route;
+use App\Framework\Auth\Auth;
+
+final readonly class Images
+{
+    #[Auth]
+    #[Route('/admin/images')]
+    public function showAll(ImageRepository $imageRepository)
+    {
+        $images = $imageRepository->findAll();
+
+        echo "<div style='background-color: #222; display: grid; grid-template-columns: repeat(auto-fit, minmax(300px, 1fr)); grid-gap: 16px; padding: 16px;'>";
+
+        /** @var Image $image */
+        foreach($images as $image) {
+            echo sprintf("<a href='/images/%s'>", $image->filename);
+
+            echo "<img src='/images/" . $image->filename . "' style='width: 400px; aspect-ratio: 1; object-fit: cover; border-radius: 16px;'/>";
+
+            echo "</a>";
+
+            var_dump($image->variants[0]->filename ?? 'no variant');
+        }
+
+        echo "</div>";
+
+        debug($images);
+        die();
+    }
+}
diff --git a/src/Application/Admin/RoutesViewModel.php b/src/Application/Admin/RoutesViewModel.php
new file mode 100644
index 00000000..7e66e64e
--- /dev/null
+++ b/src/Application/Admin/RoutesViewModel.php
@@ -0,0 +1,20 @@
+<?php
+
+namespace App\Application\Admin;
+
+use App\Framework\View\Template;
+
+#[Template('routes')]
+class RoutesViewModel
+{
+    public string $name = 'Michael';
+    public string $title = 'Routes';
+
+    public function __construct(
+        public array $routes = []
+    )
+    {
+    }
+
+
+}
diff --git a/src/Application/Admin/ShowDiscovery.php b/src/Application/Admin/ShowDiscovery.php
new file mode 100644
index 00000000..9aece07f
--- /dev/null
+++ b/src/Application/Admin/ShowDiscovery.php
@@ -0,0 +1,37 @@
+<?php
+
+namespace App\Application\Admin;
+
+use App\Framework\Attributes\Route;
+use App\Framework\Auth\Auth;
+use App\Framework\Cache\Cache;
+use App\Framework\Discovery\Results\DiscoveryResults;
+use App\Framework\View\TemplateDiscoveryVisitor;
+
+class ShowDiscovery
+{
+    public function __construct(
+        private DiscoveryResults $results,
+    )
+    {
+    }
+
+    #[Auth]
+    #[Route('/admin/discovery')]
+    public function show(
+        #Cache $cache
+    )
+    {
+        $attributes = $this->results->getAllAttributeResults();
+
+        foreach ($attributes as $name => $attribute) {
+            echo "Attribute: $name <br/>";
+            echo "<ul>";
+            foreach ($attribute as $result) {
+                echo "<li>" . $result['class'] . '::'.($result['method'] ?? '').'()</li>';
+            };
+            echo "</ul>";
+        };
+
+    }
+}
diff --git a/src/Application/Admin/ShowImageSlots.php b/src/Application/Admin/ShowImageSlots.php
new file mode 100644
index 00000000..2f3c1ef6
--- /dev/null
+++ b/src/Application/Admin/ShowImageSlots.php
@@ -0,0 +1,86 @@
+<?php
+
+namespace App\Application\Admin;
+
+use App\Domain\Media\ImageSlot;
+use App\Domain\Media\ImageSlotRepository;
+use App\Framework\Attributes\Route;
+use App\Framework\Auth\Auth;
+use App\Framework\Http\Method;
+use App\Framework\Http\Request;
+use App\Framework\Meta\MetaData;
+use App\Framework\Router\Result\ViewResult;
+
+class ShowImageSlots
+{
+    public function __construct(
+        private ImageSlotRepository $imageSlotRepository,
+    ) {}
+
+    #[Auth]
+    #[Route('/admin/imageslots')]
+    public function show()
+    {
+        $slots = $this->imageSlotRepository->getSlots();
+
+        /** @var ImageSlot $slot */
+        foreach($slots as $slot) {
+            #echo $slot->slotName . '<br/>';
+
+            if($slot->image !== null) {
+            #    echo $slot->image->filename . '<br/>';
+            }
+
+            $slotName = $slot->slotName;
+
+        }
+
+        return new ViewResult('imageslots', new MetaData('Image Slots', 'Image Slots'), [
+            'slotName' => $slotName,
+            'slots' => $slots,
+        ]);
+    }
+
+    #[Auth]
+    #[Route('/admin/imageslots/{slotName}', method: Method::POST)]
+    public function update(string $slotName): ViewResult
+    {
+        $slot = $this->imageSlotRepository->findBySlotName(urldecode($slotName));
+
+        $slotName = $slot->slotName;
+
+        #echo "<input type='text' value='$slotName' />";
+
+        return new ViewResult('imageslot', new MetaData('Image Slot', 'Image Slots'), [
+            'slotName' => $slotName,
+            'id' => $slot->id,
+        ]);
+    }
+
+    #[Auth]
+    #[Route('/admin/imageslots/create', method: Method::POST)]
+    public function create(Request $request)
+    {
+        $name = $request->parsedBody->get('slotName');
+
+        $slot = new ImageSlot(0, $name, '');
+
+        $this->imageSlotRepository->save($slot);
+
+        debug($name);
+    }
+
+    #[Auth]
+    #[Route('/admin/imageslots/edit/{id}', method: Method::PUT)]
+    public function edit(Request $request, string $id)
+    {
+        $name = $request->parsedBody->get('slotName');
+
+        $slot = $this->imageSlotRepository->findById((int)$id);
+
+
+        $slot = new ImageSlot($slot->id, $name, $slot->imageId);
+
+        $this->imageSlotRepository->save($slot);
+    }
+}
diff --git a/src/Application/Admin/ShowImageUpload.php b/src/Application/Admin/ShowImageUpload.php
new file mode 100644
index 00000000..859a1a71
--- /dev/null
+++ b/src/Application/Admin/ShowImageUpload.php
@@ -0,0 +1,146 @@
+<?php
+
+namespace App\Application\Admin;
+
+use App\Domain\Media\Image;
+use App\Domain\Media\ImageRepository;
+use App\Domain\Media\ImageResizer;
+use App\Domain\Media\ImageVariantRepository;
+use App\Domain\Media\SaveImageFile;
+use App\Framework\Attributes\Route;
+use App\Framework\Auth\Auth;
+use App\Framework\Core\PathProvider;
+use App\Framework\Database\Transaction;
+use App\Framework\DateTime\SystemClock;
+use App\Framework\Http\Method;
+use App\Framework\Http\Request;
+use App\Framework\Http\UploadedFile;
+use App\Framework\Ulid\StringConverter;
+use App\Framework\Ulid\Ulid;
+use Media\Services\ImageService;
+use function imagecopyresampled;
+use function imagecreatefromjpeg;
+use function imagecreatetruecolor;
+use function imagedestroy;
+use function imagejpeg;
+
+class ShowImageUpload
+{
+    public function __construct(
+        private PathProvider $pathProvider,
+        private StringConverter $stringConverter,
+    ) {}
+
+    #[Auth]
+    #[Route('/upload')]
+    public function __invoke()
+    {
+        $html = <<<HTML
+        <form action="/upload" method="post" enctype="multipart/form-data">
+            <label for="image">Bild hochladen:</label>
+            <input type="file" id="image" name="image" accept="image/*" required/>
+            <input type="submit" value="Upload" />
+        </form>
+
+        HTML;
+
+        echo $html;
+        die();
+    }
+    #[Auth]
+    #[Route('/upload', Method::POST)]
+    public function upload(Request $request, Ulid $ulid, ImageRepository $imageRepository, ImageVariantRepository $imageVariantRepository,)
+    {
+        try {
+            /** @var UploadedFile $file */
+            $file = $request->files->get('image');
+
+
+            $storageFolder = $this->pathProvider->resolvePath('/storage');
+
+            // Todo: Use Clock instead of date();
+            $uploadDirectory = sprintf('uploads/%s/%s/%s', date('Y'), date('m'), date('d'));
+
+            $ulid = (string)$ulid; //$this->stringConverter->encodeBase32($ulid);
+
+            $id = $ulid;
+
+            // Remove Timestamp
+            $id = substr($id, 10);
+
+            $hash = hash_file('sha256', $file->tmpName);
+
+            // Prüfen, ob ein Bild mit diesem Hash bereits existiert
+            $existingImage = $imageRepository->findByHash($hash);
+            if ($existingImage !== null) {
+                echo "<h2>Bild bereits vorhanden</h2>";
+                echo "<p>Dieses Bild wurde bereits hochgeladen.</p>";
+                echo "<p>Bild-ID: " . htmlspecialchars($existingImage->ulid) . "</p>";
+                return;
+            }
+
+            $idStr = str_pad((string)$id, 9, '0', STR_PAD_LEFT);
+            $filePathPattern = sprintf('%s/%s/%s',
+                substr($idStr, 0, 3),
+                substr($idStr, 3, 3),
+                substr($idStr, 6, 3),
+            );
+
+            $path = $storageFolder . '/' . $uploadDirectory . '/' . $filePathPattern . "/";
+
+            $filename = $idStr . '_' . $hash . "_";
+
+            #dd($path . $filename . 'variant.png');
+
+            $smallPath = $path . $filename . 'small.png';
+
+
+
+
+            [$width, $height] = getimagesize($file->tmpName);
+
+
+
+            $image = new Image(
+                ulid            : $ulid,
+                filename        : $filename . 'original.jpg',
+                originalFilename: $file->name,
+                mimeType        : $file->getMimeType(),
+                fileSize        : $file->size,
+                width           : $width,
+                height          : $height,
+                hash            : $hash,
+                path            : $path,
+                altText         : 'Some alt text',
+            );
+
+
+
+            $imageRepository->save($image, $file->tmpName);
+
+
+
+            #$image = $imageRepository->findById("0197B2CD759501F08D60312AE62ACCFC");
+
+            #mkdir($path, 0755, true);
+            $variant = new ImageResizer()($image, 50, 50);
+
+            $imageVariantRepository->save($variant);;
+
+            $href = "/images/".$variant->filename;
+            echo "<a href='$href'>$href</a>";
+
+
+            #new SaveImageFile()($image, $file->tmpName);;
+            debug($variant->filename);
+            dd($image);
+
+
+
+        } catch (\Exception $e) {
+            echo "<h2>Fehler beim Upload:</h2>";
+            echo "<p>" . htmlspecialchars($e->getMessage()) . "</p>";
+            debug($e);
+        }
+    }
+}
diff --git a/src/Application/Admin/ShowRoutes.php b/src/Application/Admin/ShowRoutes.php
new file mode 100644
index 00000000..4519e416
--- /dev/null
+++ b/src/Application/Admin/ShowRoutes.php
@@ -0,0 +1,56 @@
+<?php
+
+namespace App\Application\Admin;
+
+use App\Framework\Attributes\Route;
+use App\Framework\Auth\Auth;
+use App\Framework\Core\PathProvider;
+use App\Framework\Core\RouteCache;
+use App\Framework\Discovery\Results\DiscoveryResults;
+use App\Framework\Meta\MetaData;
+use App\Framework\Router\Result\ViewResult;
+
+final readonly class ShowRoutes
+{
+    public function __construct(
+        private PathProvider $pathProvider,
+        private DiscoveryResults $processedResults
+    ){}
+
+    #[Auth]
+    #[Route('/admin/routes')]
+    public function show(): ViewResult
+    {
+        $routes = $this->processedResults->get(Route::class);
+
+        sort($routes);
+
+        /*
+
+        echo '<div style="font-family: monospace; font-size: 12px;">';
+
+        echo str_repeat('-', 50) . "<br/>";
+
+        foreach($routes as $route) {
+                $path = $route['path'];
+                $line = "|-- $path";
+
+                $times = 50 - mb_strlen($line);
+
+                $line .= str_repeat(' .', $times) . "|<br/>";
+
+                echo $line;
+
+        }
+
+        echo str_repeat('-', 50) . "<br/></div>";*/
+
+        return new ViewResult('routes',
+            metaData: new MetaData('Routes', 'Routes'),
+            data: [
+            'name' => 'Michael',
+            'title' => 'Routes',
+        ],
+            model: new RoutesViewModel($routes));
+    }
+}
diff --git a/src/Application/Admin/templates/admin-main.view.php b/src/Application/Admin/templates/admin-main.view.php
new file mode 100644
index 00000000..a7908c9b
--- /dev/null
+++ b/src/Application/Admin/templates/admin-main.view.php
@@ -0,0 +1,27 @@
+<!doctype html>
+<html lang="de">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport"
+          content="width=device-width, user-scalable=no, initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0">
+    <meta http-equiv="X-UA-Compatible" content="ie=edge">
+    <title>Admin</title>
+    <meta name="description" content="Admin">
+    <meta property="og:type" content="Admin">
+</head>
+<body>
+
+<!--<header>
+    <h2>Admin</h2>
+</header>-->
+
+<menu>
+    <li><a href="/admin">Dashboard</a></li>
+</menu>
+
+
+<main></main>
+
+
+</body>
+</html>
diff --git a/src/Application/Admin/templates/dashboard.view.php b/src/Application/Admin/templates/dashboard.view.php
new file mode 100644
index 00000000..291f3b14
--- /dev/null
+++ b/src/Application/Admin/templates/dashboard.view.php
@@ -0,0 +1,146 @@
+<layout src="admin-main"/>
+
+<a href="/admin/routes">Routes</a>
+
+<br>
+
+<a href="/admin/imageslots">Image Slots</a>
+
+
+<div class="section">
+    <h2>Basis-Cards (nur semantische Selektoren)</h2>
+    <div class="demo-grid">
+        <article class="card">
+            <header>
+                <div>
+                    <h3>Projekt Alpha</h3>
+                    <small>Erstellt am 10. Juli 2025</small>
+                </div>
+                <span role="status">Aktiv</span>
+            </header>
+            <main>
+                <p>Diese Card nutzt nur semantische HTML-Elemente. Das Styling erfolgt über Selektoren wie <code>.card > header</code> und <code>.card h3</code>.</p>
+                <p>Weniger Klassen, sauberer HTML-Code.</p>
+            </main>
+            <footer>
+                <small>Letztes Update: heute</small>
+                <div>
+                    <button>Öffnen</button>
+                    <button>Teilen</button>
+                </div>
+            </footer>
+        </article>
+
+        <article class="card">
+            <header>
+                <h3>Einfache Card</h3>
+            </header>
+            <main>
+                <p>Minimaler HTML-Code, maximale Semantik.</p>
+            </main>
+            <footer>
+                <div>
+                    <button>Action</button>
+                </div>
+            </footer>
+        </article>
+    </div>
+</div>
+
+<div class="section">
+    <h2>Status-Varianten (Klassen für Varianten)</h2>
+    <div class="demo-grid">
+        <article class="card card--success">
+            <header>
+                <h3>Erfolg</h3>
+                <span role="status">Abgeschlossen</span>
+            </header>
+            <main>
+                <p>Success-Variante durch eine einzige Modifier-Klasse.</p>
+            </main>
+            <footer>
+                <div>
+                    <button>Details</button>
+                </div>
+            </footer>
+        </article>
+
+        <article class="card card--error">
+            <header>
+                <h3>Fehler</h3>
+                <span role="status">Problem</span>
+            </header>
+            <main>
+                <p>Error-Variante mit systematischen Farben.</p>
+            </main>
+            <footer>
+                <div>
+                    <button>Beheben</button>
+                    <button>Ignorieren</button>
+                </div>
+            </footer>
+        </article>
+    </div>
+</div>
+
+<div class="section">
+    <h2>Größen-Varianten</h2>
+    <div class="demo-grid">
+        <article class="card card--compact">
+            <header>
+                <h3>Kompakt</h3>
+            </header>
+            <main>
+                <p>Weniger Padding durch Modifier-Klasse.</p>
+            </main>
+        </article>
+
+        <article class="card card--spacious">
+            <header>
+                <h3>Großzügig</h3>
+            </header>
+            <main>
+                <p>Mehr Weißraum für wichtige Inhalte.</p>
+            </main>
+            <footer>
+                <div>
+                    <button>Hauptaktion</button>
+                </div>
+            </footer>
+        </article>
+    </div>
+</div>
+
+<div class="section">
+    <h2>Layout-Varianten</h2>
+    <div class="demo-grid demo-grid--wide">
+        <article class="card card--horizontal">
+            <header>
+                <h3>Horizontal</h3>
+            </header>
+            <main>
+                <p>Horizontales Layout durch Modifier.</p>
+            </main>
+            <footer>
+                <div>
+                    <button>Action</button>
+                </div>
+            </footer>
+        </article>
+
+        <article class="card card--media">
+            <img src="https://picsum.photos/400/200?random=2" alt="Demo">
+            <header>
+                <h3>Mit Media</h3>
+            </header>
+            <main>
+                <p>Bild wird durch Selector <code>.card--media img</code> gestylt.</p>
+            </main>
+            <footer>
+                <div>
+                    <button>Ansehen</button>
+                </div>
+            </footer>
+        </article>
+    </div>
+</div>
diff --git a/src/Application/Admin/templates/imageslot.view.php b/src/Application/Admin/templates/imageslot.view.php
new file mode 100644
index 00000000..789f2d81
--- /dev/null
+++ b/src/Application/Admin/templates/imageslot.view.php
@@ -0,0 +1,11 @@
+<layout src="admin-main"/>
+
+<form action='/admin/imageslots/edit/{{ id }}' method='post'>
+    <input type='hidden' name='_method' value='PUT'/>
+
+    <label>Slot Name:
+        <input type='text' name='slotName' value='{{ slotName }}'/>
+    </label>
+    <input type='submit' value='Update'/>
+
+</form>
diff --git a/src/Application/Admin/templates/imageslots.view.php b/src/Application/Admin/templates/imageslots.view.php
new file mode 100644
index 00000000..86f74422
--- /dev/null
+++ b/src/Application/Admin/templates/imageslots.view.php
@@ -0,0 +1,21 @@
+<layout src="admin-main"/>
+
+<for var="slot" in="slots">
+
+<form action='/admin/imageslots/{{ slot.slotName }}' method='post'>
+
+    <h3>{{ slot.slotName }}</h3>
+    <input type='submit' value='Update'/>
+
+</form>
+
+</for>
+
+<form action='/admin/imageslots/create' method='post'>
+
+    <label>Slot Name:
+        <input type='text' name='slotName' value=''/>
+    </label>
+    <input type='submit' value='Create'/>
+
+</form>
diff --git a/src/Application/Admin/templates/routes.view.php b/src/Application/Admin/templates/routes.view.php
new file mode 100644
index 00000000..6e3d40a8
--- /dev/null
+++ b/src/Application/Admin/templates/routes.view.php
@@ -0,0 +1,11 @@
+<layout src="admin-main"/>
+
+<div>Routes Page</div>
+
+<p>{{ name }}</p>
+
+<ul>
+    <for var="route" in="routes">
+        <li><a href="{{ route.path }}">{{ route.path }} </a> <i> ({{ route.class }})  {{ route.attributes.0 }} </i> </li>
+    </for>
+</ul>
diff --git a/src/Application/Admin/views/admin/dashboard.php b/src/Application/Admin/views/admin/dashboard.php
new file mode 100644
index 00000000..38a48d5e
--- /dev/null
+++ b/src/Application/Admin/views/admin/dashboard.php
@@ -0,0 +1,96 @@
+<!DOCTYPE html>
+<html lang="de">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title><?= $title ?></title>
+    <link rel="stylesheet" href="/css/admin.css">
+</head>
+<body class="admin-page">
+    <div class="admin-header">
+        <h1>Framework Admin Dashboard</h1>
+    </div>
+
+    <div class="admin-nav">
+        <a href="/admin" class="active">Dashboard</a>
+        <a href="/admin/routes">Routen</a>
+        <a href="/admin/services">Dienste</a>
+        <a href="/admin/environment">Umgebung</a>
+        <a href="/admin/performance">Performance</a>
+        <a href="/admin/redis">Redis</a>
+        <a href="/admin/phpinfo">PHP Info</a>
+    </div>
+
+    <div class="admin-content">
+        <div class="dashboard-stats">
+            <div class="stat-box">
+                <h3>Framework Version</h3>
+                <div class="stat-value"><?= $stats['frameworkVersion'] ?></div>
+            </div>
+
+            <div class="stat-box">
+                <h3>PHP Version</h3>
+                <div class="stat-value"><?= $stats['phpVersion'] ?></div>
+            </div>
+
+            <div class="stat-box">
+                <h3>Speicherverbrauch</h3>
+                <div class="stat-value"><?= $stats['memoryUsage'] ?></div>
+            </div>
+
+            <div class="stat-box">
+                <h3>Max. Speicherverbrauch</h3>
+                <div class="stat-value"><?= $stats['peakMemoryUsage'] ?></div>
+            </div>
+
+            <div class="stat-box">
+                <h3>Server</h3>
+                <div class="stat-value"><?= $stats['serverInfo'] ?></div>
+            </div>
+
+            <div class="stat-box">
+                <h3>Serverzeit</h3>
+                <div class="stat-value"><?= $stats['serverTime'] ?></div>
+            </div>
+
+            <div class="stat-box">
+                <h3>Zeitzone</h3>
+                <div class="stat-value"><?= $stats['timezone'] ?></div>
+            </div>
+
+            <div class="stat-box">
+                <h3>Betriebssystem</h3>
+                <div class="stat-value"><?= $stats['operatingSystem'] ?></div>
+            </div>
+
+            <div class="stat-box">
+                <h3>Server Uptime</h3>
+                <div class="stat-value"><?= $stats['uptime'] ?></div>
+            </div>
+
+            <div class="stat-box">
+                <h3>Aktive Sessions</h3>
+                <div class="stat-value"><?= $stats['sessionCount'] ?></div>
+            </div>
+
+            <div class="stat-box">
+                <h3>Registrierte Dienste</h3>
+                <div class="stat-value"><?= $stats['servicesCount'] ?></div>
+            </div>
+        </div>
+
+        <div class="admin-section">
+            <h2>PHP Erweiterungen</h2>
+            <div class="extensions-list">
+                <?php foreach($stats['loadedExtensions'] as $extension): ?>
+                    <span class="extension-badge"><?= $extension ?></span>
+                <?php endforeach; ?>
+            </div>
+        </div>
+    </div>
+
+    <div class="admin-footer">
+        <p>&copy; <?= date('Y') ?> Framework Admin</p>
+    </div>
+</body>
+</html>
diff --git a/src/Application/Admin/views/admin/environment.php b/src/Application/Admin/views/admin/environment.php
new file mode 100644
index 00000000..e7ea21fa
--- /dev/null
+++ b/src/Application/Admin/views/admin/environment.php
@@ -0,0 +1,86 @@
+<!DOCTYPE html>
+<html lang="de">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title><?= $title ?></title>
+    <link rel="stylesheet" href="/css/admin.css">
+</head>
+<body class="admin-page">
+    <div class="admin-header">
+        <h1>Umgebungsvariablen</h1>
+    </div>
+
+    <div class="admin-nav">
+        <a href="/admin">Dashboard</a>
+        <a href="/admin/routes">Routen</a>
+        <a href="/admin/services">Dienste</a>
+        <a href="/admin/environment" class="active">Umgebung</a>
+        <a href="/admin/performance">Performance</a>
+        <a href="/admin/redis">Redis</a>
+        <a href="/admin/phpinfo">PHP Info</a>
+    </div>
+
+    <div class="admin-content">
+        <div class="admin-tools">
+            <input type="text" id="envFilter" placeholder="Variablen filtern..." class="search-input">
+            <div class="filter-tags">
+                <button class="filter-tag" data-prefix="APP_">APP_</button>
+                <button class="filter-tag" data-prefix="DB_">DB_</button>
+                <button class="filter-tag" data-prefix="REDIS_">REDIS_</button>
+                <button class="filter-tag" data-prefix="RATE_LIMIT_">RATE_LIMIT_</button>
+                <button class="filter-tag" data-prefix="PHP_">PHP_</button>
+                <button class="filter-tag active" data-prefix="">Alle</button>
+            </div>
+        </div>
+
+        <table class="admin-table" id="envTable">
+            <thead>
+                <tr>
+                    <th>Variable</th>
+                    <th>Wert</th>
+                </tr>
+            </thead>
+            <tbody>
+                <?php foreach($env as $key => $value): ?>
+                <tr>
+                    <td><?= $key ?></td>
+                    <td><?= is_array($value) ? json_encode($value) : $value ?></td>
+                </tr>
+                <?php endforeach; ?>
+            </tbody>
+        </table>
+    </div>
+
+    <div class="admin-footer">
+        <p>&copy; <?= date('Y') ?> Framework Admin</p>
+    </div>
+
+    <script>
+        // Filterung der Umgebungsvariablen
+        document.getElementById('envFilter').addEventListener('input', filterTable);
+
+        // Tag-Filter
+        document.querySelectorAll('.filter-tag').forEach(tag => {
+            tag.addEventListener('click', function() {
+                document.querySelectorAll('.filter-tag').forEach(t => t.classList.remove('active'));
+                this.classList.add('active');
+
+                const prefix = this.getAttribute('data-prefix');
+                document.getElementById('envFilter').value = prefix;
+                filterTable();
+            });
+        });
+
+        function filterTable() {
+            const filterValue = document.getElementById('envFilter').value.toLowerCase();
+            const rows = document.querySelectorAll('#envTable tbody tr');
+
+            rows.forEach(row => {
+                const key = row.cells[0].textContent.toLowerCase();
+                row.style.display = key.includes(filterValue) ? '' : 'none';
+            });
+        }
+    </script>
+</body>
+</html>
diff --git a/src/Application/Admin/views/admin/performance.view.php b/src/Application/Admin/views/admin/performance.view.php
new file mode 100644
index 00000000..bca2b84d
--- /dev/null
+++ b/src/Application/Admin/views/admin/performance.view.php
@@ -0,0 +1,125 @@
+<!DOCTYPE html>
+<html lang="de">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title><?= $title ?></title>
+    <link rel="stylesheet" href="/css/admin.css">
+</head>
+<body class="admin-page">
+    <div class="admin-header">
+        <h1>Performance-Übersicht</h1>
+    </div>
+
+    <div class="admin-nav">
+        <a href="/admin">Dashboard</a>
+        <a href="/admin/routes">Routen</a>
+        <a href="/admin/services">Dienste</a>
+        <a href="/admin/environment">Umgebung</a>
+        <a href="/admin/performance" class="active">Performance</a>
+        <a href="/admin/redis">Redis</a>
+        <a href="/admin/phpinfo">PHP Info</a>
+    </div>
+
+    <div class="admin-content">
+        <div class="dashboard-stats">
+            <div class="stat-box">
+                <h3>Aktueller Speicherverbrauch</h3>
+                <div class="stat-value"><?= $performance['currentMemoryUsage'] ?></div>
+            </div>
+
+            <div class="stat-box">
+                <h3>Maximaler Speicherverbrauch</h3>
+                <div class="stat-value"><?= $performance['peakMemoryUsage'] ?></div>
+            </div>
+
+            <div class="stat-box">
+                <h3>Speicherlimit</h3>
+                <div class="stat-value"><?= $performance['memoryLimit'] ?></div>
+            </div>
+
+            <div class="stat-box">
+                <h3>Speicherauslastung</h3>
+                <div class="stat-value">
+                    <div class="progress-bar">
+                        <div class="progress" style="width: <?= $performance['memoryUsagePercentage'] ?>%"></div>
+                    </div>
+                    <div class="progress-value"><?= $performance['memoryUsagePercentage'] ?>%</div>
+                </div>
+            </div>
+
+            <div class="stat-box">
+                <h3>Systemlast (1/5/15 min)</h3>
+                <div class="stat-value">
+                    <?= $performance['loadAverage'][0] ?> /
+                    <?= $performance['loadAverage'][1] ?> /
+                    <?= $performance['loadAverage'][2] ?>
+                </div>
+            </div>
+
+            <div class="stat-box">
+                <h3>OPCache aktiviert</h3>
+                <div class="stat-value"><?= $performance['opcacheEnabled'] ?></div>
+            </div>
+
+            <?php if (isset($performance['opcacheMemoryUsage'])): ?>
+            <div class="stat-box">
+                <h3>OPCache Speicherverbrauch</h3>
+                <div class="stat-value"><?= $performance['opcacheMemoryUsage'] ?></div>
+            </div>
+
+            <div class="stat-box">
+                <h3>OPCache Cache Hits</h3>
+                <div class="stat-value"><?= $performance['opcacheCacheHits'] ?></div>
+            </div>
+
+            <div class="stat-box">
+                <h3>OPCache Miss Rate</h3>
+                <div class="stat-value"><?= $performance['opcacheMissRate'] ?></div>
+            </div>
+            <?php endif; ?>
+
+            <div class="stat-box">
+                <h3>Ausführungszeit</h3>
+                <div class="stat-value"><?= $performance['executionTime'] ?></div>
+            </div>
+
+            <div class="stat-box">
+                <h3>Geladene Dateien</h3>
+                <div class="stat-value"><?= $performance['includedFiles'] ?></div>
+            </div>
+        </div>
+
+        <div class="admin-section">
+            <h2>Geladene Dateien</h2>
+            <div class="admin-tools">
+                <input type="text" id="fileFilter" placeholder="Dateien filtern..." class="search-input">
+            </div>
+
+            <div class="file-list" id="fileList">
+                <?php foreach(get_included_files() as $file): ?>
+                <div class="file-item">
+                    <?= $file ?>
+                </div>
+                <?php endforeach; ?>
+            </div>
+        </div>
+    </div>
+
+    <div class="admin-footer">
+        <p>&copy; <?= date('Y') ?> Framework Admin</p>
+    </div>
+
+    <script>
+        document.getElementById('fileFilter').addEventListener('input', function() {
+            const filterValue = this.value.toLowerCase();
+            const items = document.querySelectorAll('#fileList .file-item');
+
+            items.forEach(item => {
+                const text = item.textContent.toLowerCase();
+                item.style.display = text.includes(filterValue) ? '' : 'none';
+            });
+        });
+    </script>
+</body>
+</html>
diff --git a/src/Application/Admin/views/admin/redis.view.php b/src/Application/Admin/views/admin/redis.view.php
new file mode 100644
index 00000000..6258f77f
--- /dev/null
+++ b/src/Application/Admin/views/admin/redis.view.php
@@ -0,0 +1,105 @@
+<!DOCTYPE html>
+<html lang="de">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title><?= $title ?></title>
+    <link rel="stylesheet" href="/css/admin.css">
+</head>
+<body class="admin-page">
+    <div class="admin-header">
+        <h1>Redis-Informationen</h1>
+    </div>
+
+    <div class="admin-nav">
+        <a href="/admin">Dashboard</a>
+        <a href="/admin/routes">Routen</a>
+        <a href="/admin/services">Dienste</a>
+        <a href="/admin/environment">Umgebung</a>
+        <a href="/admin/performance">Performance</a>
+        <a href="/admin/redis" class="active">Redis</a>
+        <a href="/admin/phpinfo">PHP Info</a>
+    </div>
+
+    <div class="admin-content">
+        <?php if (isset($redis['status']) && $redis['status'] === 'Verbunden'): ?>
+            <div class="dashboard-stats">
+                <div class="stat-box">
+                    <h3>Status</h3>
+                    <div class="stat-value status-connected"><?= $redis['status'] ?></div>
+                </div>
+
+                <div class="stat-box">
+                    <h3>Version</h3>
+                    <div class="stat-value"><?= $redis['version'] ?></div>
+                </div>
+
+                <div class="stat-box">
+                    <h3>Uptime</h3>
+                    <div class="stat-value"><?= $redis['uptime'] ?></div>
+                </div>
+
+                <div class="stat-box">
+                    <h3>Speicherverbrauch</h3>
+                    <div class="stat-value"><?= $redis['memory'] ?></div>
+                </div>
+
+                <div class="stat-box">
+                    <h3>Max. Speicherverbrauch</h3>
+                    <div class="stat-value"><?= $redis['peak_memory'] ?></div>
+                </div>
+
+                <div class="stat-box">
+                    <h3>Verbundene Clients</h3>
+                    <div class="stat-value"><?= $redis['clients'] ?></div>
+                </div>
+
+                <div class="stat-box">
+                    <h3>Anzahl Schlüssel</h3>
+                    <div class="stat-value"><?= $redis['keys'] ?></div>
+                </div>
+            </div>
+
+            <div class="admin-section">
+                <h2>Schlüssel (max. 50 angezeigt)</h2>
+                <div class="admin-tools">
+                    <input type="text" id="keyFilter" placeholder="Schlüssel filtern..." class="search-input">
+                </div>
+
+                <div class="key-list" id="keyList">
+                    <?php if (empty($redis['key_sample'])): ?>
+                        <div class="empty-message">Keine Schlüssel vorhanden</div>
+                    <?php else: ?>
+                        <?php foreach($redis['key_sample'] as $key): ?>
+                        <div class="key-item">
+                            <?= $key ?>
+                        </div>
+                        <?php endforeach; ?>
+                    <?php endif; ?>
+                </div>
+            </div>
+        <?php else: ?>
+            <div class="error-message">
+                <h2>Redis-Verbindung fehlgeschlagen</h2>
+                <p><?= $redis['status'] ?? 'Unbekannter Fehler' ?></p>
+            </div>
+        <?php endif; ?>
+    </div>
+
+    <div class="admin-footer">
+        <p>&copy; <?= date('Y') ?> Framework Admin</p>
+    </div>
+
+    <script>
+        document.getElementById('keyFilter')?.addEventListener('input', function() {
+            const filterValue = this.value.toLowerCase();
+            const items = document.querySelectorAll('#keyList .key-item');
+
+            items.forEach(item => {
+                const text = item.textContent.toLowerCase();
+                item.style.display = text.includes(filterValue) ? '' : 'none';
+            });
+        });
+    </script>
+</body>
+</html>
diff --git a/src/Application/Admin/views/admin/routes.php b/src/Application/Admin/views/admin/routes.php
new file mode 100644
index 00000000..59b1812c
--- /dev/null
+++ b/src/Application/Admin/views/admin/routes.php
@@ -0,0 +1,69 @@
+<!DOCTYPE html>
+<html lang="de">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title><?= $title ?></title>
+    <link rel="stylesheet" href="/css/admin.css">
+</head>
+<body class="admin-page">
+    <div class="admin-header">
+        <h1>Routen-Übersicht</h1>
+    </div>
+
+    <div class="admin-nav">
+        <a href="/admin">Dashboard</a>
+        <a href="/admin/routes" class="active">Routen</a>
+        <a href="/admin/services">Dienste</a>
+        <a href="/admin/environment">Umgebung</a>
+        <a href="/admin/performance">Performance</a>
+        <a href="/admin/redis">Redis</a>
+        <a href="/admin/phpinfo">PHP Info</a>
+    </div>
+
+    <div class="admin-content">
+        <div class="admin-tools">
+            <input type="text" id="routeFilter" placeholder="Routen filtern..." class="search-input">
+        </div>
+
+        <table class="admin-table" id="routesTable">
+            <thead>
+                <tr>
+                    <th>Pfad</th>
+                    <th>Methode</th>
+                    <th>Controller</th>
+                    <th>Aktion</th>
+                    <th>Name</th>
+                </tr>
+            </thead>
+            <tbody>
+                <?php foreach($routes as $route): ?>
+                <tr>
+                    <td><?= $route->path ?></td>
+                    <td><?= $route->method ?></td>
+                    <td><?= $route->controllerClass ?></td>
+                    <td><?= $route->methodName ?></td>
+                    <td><?= $route->name ?? '-' ?></td>
+                </tr>
+                <?php endforeach; ?>
+            </tbody>
+        </table>
+    </div>
+
+    <div class="admin-footer">
+        <p>&copy; <?= date('Y') ?> Framework Admin</p>
+    </div>
+
+    <script>
+        document.getElementById('routeFilter').addEventListener('input', function() {
+            const filterValue = this.value.toLowerCase();
+            const rows = document.querySelectorAll('#routesTable tbody tr');
+
+            rows.forEach(row => {
+                const text = row.textContent.toLowerCase();
+                row.style.display = text.includes(filterValue) ? '' : 'none';
+            });
+        });
+    </script>
+</body>
+</html>
diff --git a/src/Application/Admin/views/admin/services.php b/src/Application/Admin/views/admin/services.php
new file mode 100644
index 00000000..a94127d4
--- /dev/null
+++ b/src/Application/Admin/views/admin/services.php
@@ -0,0 +1,72 @@
+<!DOCTYPE html>
+<html lang="de">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title><?= $title ?></title>
+    <link rel="stylesheet" href="/css/admin.css">
+</head>
+<body class="admin-page">
+    <div class="admin-header">
+        <h1>Registrierte Dienste</h1>
+    </div>
+
+    <div class="admin-nav">
+        <a href="/admin">Dashboard</a>
+        <a href="/admin/routes">Routen</a>
+        <a href="/admin/services" class="active">Dienste</a>
+        <a href="/admin/environment">Umgebung</a>
+        <a href="/admin/performance">Performance</a>
+        <a href="/admin/redis">Redis</a>
+        <a href="/admin/phpinfo">PHP Info</a>
+    </div>
+
+    <div class="admin-content">
+        <div class="admin-tools">
+            <input type="text" id="serviceFilter" placeholder="Dienste filtern..." class="search-input">
+            <span class="services-count"><?= count($services) ?> Dienste insgesamt</span>
+        </div>
+
+        <div class="service-list" id="serviceList">
+            <?php foreach($services as $service): ?>
+            <div class="service-item">
+                <div class="service-name"><?= $service ?></div>
+                <?php
+                $parts = explode('\\', $service);
+                $category = $parts[1] ?? 'Unknown';
+                $subCategory = $parts[2] ?? '';
+                ?>
+                <div class="service-category">
+                    <span class="category-badge"><?= $category ?></span>
+                    <?php if ($subCategory): ?>
+                    <span class="subcategory-badge"><?= $subCategory ?></span>
+                    <?php endif; ?>
+                </div>
+            </div>
+            <?php endforeach; ?>
+        </div>
+    </div>
+
+    <div class="admin-footer">
+        <p>&copy; <?= date('Y') ?> Framework Admin</p>
+    </div>
+
+    <script>
+        document.getElementById('serviceFilter').addEventListener('input', function() {
+            const filterValue = this.value.toLowerCase();
+            const items = document.querySelectorAll('#serviceList .service-item');
+            let visibleCount = 0;
+
+            items.forEach(item => {
+                const text = item.textContent.toLowerCase();
+                const isVisible = text.includes(filterValue);
+                item.style.display = isVisible ? '' : 'none';
+                if (isVisible) visibleCount++;
+            });
+
+            document.querySelector('.services-count').textContent =
+                visibleCount + ' von ' + <?= count($services) ?> + ' Diensten';
+        });
+    </script>
+</body>
+</html>
diff --git a/src/Application/Api/IrkEndpoint.php b/src/Application/Api/IrkEndpoint.php
deleted file mode 100644
index 4b0ee5b3..00000000
--- a/src/Application/Api/IrkEndpoint.php
+++ /dev/null
@@ -1,21 +0,0 @@
-<?php
-
-namespace App\Application\Api;
-
-use App\Framework\Attributes\Route;
-use App\Framework\Router\ActionResult;
-
-class IrkEndpoint
-{
-    #[Route(method: 'GET', path: '/irk-impressum')]
-    public function impressum()
-    {
-        return;
-    }
-
-    #[Route(method: 'GET', path: '/irk-datenschutz')]
-    public function datenschutz()
-    {
-        return;
-    }
-}
diff --git a/src/Application/Auth/LoginRequest.php b/src/Application/Auth/LoginRequest.php
new file mode 100644
index 00000000..90e200c9
--- /dev/null
+++ b/src/Application/Auth/LoginRequest.php
@@ -0,0 +1,14 @@
+<?php
+
+namespace App\Application\Auth;
+
+use App\Framework\Http\ControllerRequest;
+use App\Framework\Validation\Rules\Email;
+
+final readonly class LoginRequest implements ControllerRequest
+{
+    #[Email]
+    public string $email;
+
+    public string $password;
+}
diff --git a/src/Application/Auth/LoginUser.php b/src/Application/Auth/LoginUser.php
new file mode 100644
index 00000000..2e3f1ea4
--- /dev/null
+++ b/src/Application/Auth/LoginUser.php
@@ -0,0 +1,13 @@
+<?php
+
+namespace App\Application\Auth;
+
+class LoginUser
+{
+    public function __construct(
+        public string $email,
+        public string $password
+    )
+    {
+    }
+}
diff --git a/src/Application/Auth/LoginUserHandler.php b/src/Application/Auth/LoginUserHandler.php
new file mode 100644
index 00000000..81ffe07a
--- /dev/null
+++ b/src/Application/Auth/LoginUserHandler.php
@@ -0,0 +1,14 @@
+<?php
+
+namespace App\Application\Auth;
+
+use App\Framework\CommandBus\CommandHandler;
+
+class LoginUserHandler
+{
+    #[CommandHandler]
+    public function __invoke(LoginUser $loginUser)
+    {
+        var_dump($loginUser);
+    }
+}
diff --git a/src/Application/Auth/ShowLogin.php b/src/Application/Auth/ShowLogin.php
new file mode 100644
index 00000000..525e3eb0
--- /dev/null
+++ b/src/Application/Auth/ShowLogin.php
@@ -0,0 +1,38 @@
+<?php
+
+namespace App\Application\Auth;
+
+use App\Framework\Attributes\Route;
+use App\Framework\Auth\Auth;
+use App\Framework\CommandBus\CommandBus;
+use App\Framework\Http\Method;
+use App\Framework\Router\Result\ViewResult;
+
+class ShowLogin
+{
+    public function __construct(
+        private CommandBus $commandBus,
+    )
+    {
+    }
+
+    #[Auth]
+    #[Route('/login')]
+    public function __invoke()
+    {
+        return new ViewResult('loginform');
+
+    }
+
+    #[Auth]
+    #[Route('/login', Method::POST)]
+    public function login(LoginRequest $request)
+    {
+        $login = new LoginUser($request->email, $request->password);
+
+        $this->commandBus->dispatch($login);
+
+        dd($request);
+
+    }
+}
diff --git a/src/Application/Auth/templates/loginform.view.php b/src/Application/Auth/templates/loginform.view.php
new file mode 100644
index 00000000..00273e78
--- /dev/null
+++ b/src/Application/Auth/templates/loginform.view.php
@@ -0,0 +1,9 @@
+<layout src="loginform"/>
+
+<form action="/login" method="post">
+    <label for="email">Email:</label>
+    <input type="email" id="email" name="email" required/>
+    <label for="password">Password:</label>
+    <input type="password" id="password" name="password" required/>
+    <input type="submit" value="Login" />
+</form>
diff --git a/src/Application/Backend/RapidMail/Dashbord.php b/src/Application/Backend/RapidMail/Dashbord.php
new file mode 100644
index 00000000..437c631c
--- /dev/null
+++ b/src/Application/Backend/RapidMail/Dashbord.php
@@ -0,0 +1,46 @@
+<?php
+
+namespace App\Application\Backend\RapidMail;
+
+use App\Framework\Attributes\Route;
+use App\Infrastructure\Api\RapidMail\Commands\UpdateRecipientCommand;
+use App\Infrastructure\Api\RapidMail\RapidMailClient;
+use App\Infrastructure\Api\RapidMail\Recipient;
+use App\Infrastructure\Api\RapidMail\RecipientId;
+
+final readonly class Dashbord
+{
+    public function __construct(
+        private RapidMailClient $rapidMailClient
+    )
+    {
+    }
+
+    #[Route(path: '/rapidmail', name: 'rapidmail')]
+    public function __invoke()
+    {
+        $all = $this->rapidMailClient->recipients->get(RecipientId::fromInt(629237));
+        #debug($all);
+
+
+        #debug($all->email);
+
+        $command = new UpdateRecipientCommand(
+            $all->id,
+            $all->email,
+            'Test',
+        );
+
+        $user = $this->rapidMailClient->recipients->updateWithCommand($command);
+
+        #$user = $this->rapidMailClient->recipients->update(629237, Recipient::fromArray($array));
+
+        #$data = $this->rapidMailClient->recipientLists->getAll(); //->get(776);
+
+        #$name = $data[0]->name;
+
+        #$data = $this->rapidMailClient->statistics->getMailingStats(776);
+
+        debug($user);
+    }
+}
diff --git a/src/Application/Contact/ContactRequest.php b/src/Application/Contact/ContactRequest.php
new file mode 100644
index 00000000..6616b8d1
--- /dev/null
+++ b/src/Application/Contact/ContactRequest.php
@@ -0,0 +1,14 @@
+<?php
+
+namespace App\Application\Contact;
+
+use App\Framework\Http\ControllerRequest;
+use App\Framework\Validation\Rules\Email;
+
+class ContactRequest implements ControllerRequest
+{
+    public string $name;
+    #[Email]
+    public string $email;
+    public string $message;
+}
diff --git a/src/Application/Contact/ShowContact.php b/src/Application/Contact/ShowContact.php
new file mode 100644
index 00000000..7ba09903
--- /dev/null
+++ b/src/Application/Contact/ShowContact.php
@@ -0,0 +1,47 @@
+<?php
+
+namespace App\Application\Contact;
+
+use App\Framework\Attributes\Route;
+use App\Framework\CommandBus\CommandBus;
+use App\Framework\Http\Method;
+use App\Framework\Meta\Keywords;
+use App\Framework\Meta\StaticPageMetaResolver;
+use App\Framework\Router\ActionResult;
+use App\Framework\Router\Result\ContentNegotiationResult;
+use App\Framework\Router\Result\ViewResult;
+
+final readonly class ShowContact
+{
+    #[Route(path: '/kontakt', name: 'contact')]
+    public function __invoke(): ViewResult
+    {
+        return new ViewResult('contact',
+            new StaticPageMetaResolver(
+                'Kontakt',
+                'Kontaktseite!',
+                Keywords::fromStrings('Kontakt', 'Welt')
+            )(),);
+    }
+
+    #[Route(path: '/kontakt', method: Method::POST)]
+    public function senden(ContactRequest $request, CommandBus $commandBus): ActionResult
+    {
+
+        $command = new StoreContact(
+            $request->email,
+            $request->name,
+            $request->subject ?? 'Kein Betreff angegeben',
+            $request->message,
+        );
+
+        $commandBus->dispatch($command);
+
+        dd($request);
+
+        return new ContentNegotiationResult(
+
+        );
+        #return new ViewResult('contact-senden');
+    }
+}
diff --git a/src/Application/Contact/StoreContact.php b/src/Application/Contact/StoreContact.php
new file mode 100644
index 00000000..cd41c499
--- /dev/null
+++ b/src/Application/Contact/StoreContact.php
@@ -0,0 +1,14 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Application\Contact;
+
+final class StoreContact
+{
+    public function __construct(
+        public string $name,
+        public string $email,
+        public string $subject,
+        public string $message,
+    ) {}
+}
diff --git a/src/Application/Contact/StoreContactHandler.php b/src/Application/Contact/StoreContactHandler.php
new file mode 100644
index 00000000..f98a26f6
--- /dev/null
+++ b/src/Application/Contact/StoreContactHandler.php
@@ -0,0 +1,22 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Application\Contact;
+
+use App\Domain\Contact\ContactMessage;
+use App\Domain\Contact\ContactRepository;
+use App\Framework\CommandBus\CommandHandler;
+
+final readonly class StoreContactHandler
+{
+    public function __construct(
+        private ContactRepository $contactRepository,
+    ) {}
+    #[CommandHandler]
+    public function __invoke(StoreContact $command): void
+    {
+        $message = new ContactMessage($command->name, $command->email, $command->message);
+
+        $this->contactRepository->save($message);
+    }
+}
diff --git a/src/Application/Contact/contact.view.php b/src/Application/Contact/contact.view.php
new file mode 100644
index 00000000..30153fed
--- /dev/null
+++ b/src/Application/Contact/contact.view.php
@@ -0,0 +1,74 @@
+<layout src="main"/>
+
+<section>
+
+<h1>Kontakt</h1>
+
+
+<form action="/kontakt" method="post">
+
+    <!-- Feld ist für Bots gedacht – normaler User sieht es nicht -->
+    <div style="position: absolute; left: -10000px; top: auto;" aria-hidden="true">
+        <label for="website">Ihre Website:</label>
+        <input type="text" name="website" id="website" tabindex="-1" autocomplete="off">
+    </div>
+
+    <div role="alert">
+        Hallo Welt
+    </div>
+
+    <label for="name">Name:</label>
+    <input type="text" name="name" id="name">
+
+    <label for="email">E-Mail:</label>
+    <input type="email" name="email" id="email">
+
+    <label for="subject">Betreff:</label>
+    <select name="subject" id="subject">
+        <option value="1">Anfrage</option>
+        <option value="2">Beschwerde</option>
+        <option value="3">Anregung</option>
+        <option value="4">Sonstiges</option>
+    </select>
+
+    <label for="message">Nachricht:</label>
+    <textarea name="message" id="message"></textarea>
+
+
+    <input type="submit" value="Senden">
+
+</form>
+
+</section>
+
+<style>
+    div.box {
+        background: red;
+
+    }
+
+    div.outer {
+        --outer-radius: 24px;
+        --padding: 8px;
+        --inner-radius: calc(var(--outer-radius) - var(--padding));
+
+        border-radius: var(--outer-radius);
+        padding: var(--padding);
+
+        box-shadow: 0 0 10px 0 rgba(0, 0, 0, 0.2);
+
+        box-sizing: border-box;
+
+    }
+
+    .inner {
+        border-radius: var(--inner-radius);
+        --padding: 1rem;
+        padding:inherit;
+    }
+</style>
+
+<div class="box outer" style="background: grey;">
+    Testbox
+</div>
+
diff --git a/src/Application/EPK/ShowEpk.php b/src/Application/EPK/ShowEpk.php
index 7d9662f7..a98adcc4 100644
--- a/src/Application/EPK/ShowEpk.php
+++ b/src/Application/EPK/ShowEpk.php
@@ -4,13 +4,15 @@ namespace App\Application\EPK;
 
 use App\Framework\Attributes\Route;
 use App\Framework\Router\ActionResult;
+use App\Framework\Router\GenericActionResult;
+use App\Framework\Router\Result\ViewResult;
 use App\Framework\Router\ResultType;
 
 class ShowEpk
 {
-    #[Route(path: '/epk')]
+    #[Route(path: '/epk', name: 'epk')]
     public function epk(): ActionResult
     {
-        return new ActionResult(ResultType::Html, 'epk', ['text' => 'EPK!']);
+        return new ViewResult('epk', new MetaData('title'));
     }
 }
diff --git a/src/Application/Http/Controllers/ChatController.php b/src/Application/Http/Controllers/ChatController.php
new file mode 100644
index 00000000..4857faa6
--- /dev/null
+++ b/src/Application/Http/Controllers/ChatController.php
@@ -0,0 +1,108 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Application\Http\Controllers;
+
+use App\Framework\Attributes\Route;
+use App\Framework\Auth\Auth;
+use App\Framework\Http\Method;
+use App\Framework\Http\WebSocketConnection;
+use App\Framework\Router\Result\WebSocketResult;
+
+final class ChatController
+{
+    private array $connections = [];
+
+    #[Auth]
+    #[Route(path: '/chat/websocket', method: Method::GET)]
+    public function chatWebSocket(): WebSocketResult
+    {
+        return new WebSocketResult()
+            ->onConnect(function(WebSocketConnection $connection) {
+                $this->connections[$connection->getId()] = $connection;
+
+                // Willkommensnachricht senden
+                $connection->sendJson([
+                    'type' => 'system',
+                    'message' => 'Willkommen im Chat!',
+                    'timestamp' => time()
+                ]);
+
+                // Andere Benutzer benachrichtigen
+                $this->broadcast([
+                    'type' => 'user_joined',
+                    'message' => 'Ein neuer Benutzer ist dem Chat beigetreten',
+                    'timestamp' => time()
+                ], $connection->getId());
+            })
+            ->onMessage(function(WebSocketConnection $connection, string $message) {
+                $data = json_decode($message, true);
+
+                if (!$data || !isset($data['type'])) {
+                    $connection->sendJson(['error' => 'Invalid message format']);
+                    return;
+                }
+
+                switch ($data['type']) {
+                    case 'chat_message':
+                        $this->handleChatMessage($connection, $data);
+                        break;
+                    case 'ping':
+                        $connection->sendJson(['type' => 'pong']);
+                        break;
+                    default:
+                        $connection->sendJson(['error' => 'Unknown message type']);
+                }
+            })
+            ->onClose(function(WebSocketConnection $connection, int $code, string $reason) {
+                unset($this->connections[$connection->getId()]);
+
+                // Andere Benutzer benachrichtigen
+                $this->broadcast([
+                    'type' => 'user_left',
+                    'message' => 'Ein Benutzer hat den Chat verlassen',
+                    'timestamp' => time()
+                ]);
+            })
+            ->onError(function(WebSocketConnection $connection, \Throwable $error) {
+                error_log("WebSocket error: " . $error->getMessage());
+                $connection->close(1011, 'Internal server error');
+            })
+            ->withSubprotocols(['chat'])
+            ->withMaxMessageSize(10240) // 10KB
+            ->withPingInterval(30); // 30 Sekunden
+    }
+
+    private function handleChatMessage(WebSocketConnection $sender, array $data): void
+    {
+        if (!isset($data['message'])) {
+            $sender->sendJson(['error' => 'Message content required']);
+            return;
+        }
+
+        $message = [
+            'type' => 'chat_message',
+            'user_id' => $sender->getId(),
+            'message' => $data['message'],
+            'timestamp' => time()
+        ];
+
+        // Nachricht an alle Verbindungen senden
+        $this->broadcast($message);
+    }
+
+    private function broadcast(array $message, ?string $excludeId = null): void
+    {
+        foreach ($this->connections as $id => $connection) {
+            if ($excludeId && $id === $excludeId) {
+                continue;
+            }
+
+            if ($connection->isConnected()) {
+                $connection->sendJson($message);
+            } else {
+                unset($this->connections[$id]);
+            }
+        }
+    }
+}
diff --git a/src/Application/Http/Controllers/NotificationController.php b/src/Application/Http/Controllers/NotificationController.php
new file mode 100644
index 00000000..e082ff19
--- /dev/null
+++ b/src/Application/Http/Controllers/NotificationController.php
@@ -0,0 +1,160 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Application\Http\Controllers;
+
+use App\Framework\Attributes\Route;
+use App\Framework\Auth\Auth;
+use App\Framework\Http\Method;
+use App\Framework\Http\SseStream;
+use App\Framework\Http\Status;
+use App\Framework\Router\Result\SseResult;
+use App\Framework\Router\Result\SseResultWithCallback;
+
+/**
+ * Controller für Echtzeit-Benachrichtigungen über Server-Sent Events
+ */
+final class NotificationController
+{
+    /**
+     * Stellt einen SSE-Stream für allgemeine Benachrichtigungen bereit
+     */
+    #[Auth]
+    #[Route(path: '/api/notifications/stream', method: Method::GET)]
+    public function notificationStream(): SseResult
+    {
+        // SSE-Result mit 3 Sekunden Retry-Intervall
+        $result = new SseResult(Status::OK, 3000);
+
+        // Initiale Verbindungsbestätigung
+        $result->addJsonEvent(
+            ['message' => 'Verbunden mit dem Benachrichtigungsstream'],
+            'connected',
+            'conn-' . uniqid()
+        );
+
+        // Einige Beispiel-Benachrichtigungen beim Start senden
+        $result->addJsonEvent(
+            [
+                'type' => 'info',
+                'title' => 'Willkommen',
+                'message' => 'Sie sind jetzt mit Echtzeit-Updates verbunden.',
+                'timestamp' => time()
+            ],
+            'notification',
+            'notif-' . uniqid()
+        );
+
+        return $result;
+    }
+
+    /**
+     * Stellt einen benutzer-spezifischen SSE-Stream bereit
+     */
+    #[Auth]
+    #[Route(path: '/api/notifications/user/{userId}', method: Method::GET)]
+    public function userNotifications(int $userId): SseResult
+    {
+        // SSE-Result mit benutzerdefinierten Headern
+        $result = new SseResult(Status::OK, 3000, [
+            'X-User-ID' => (string)$userId
+        ]);
+
+        // Verbindungsbestätigung mit Benutzer-ID
+        $result->addJsonEvent(
+            [
+                'message' => 'Verbunden mit dem Benutzer-Stream',
+                'userId' => $userId,
+                'timestamp' => time()
+            ],
+            'connected',
+            'conn-user-' . $userId
+        );
+
+        // Aktuelle Benachrichtigungen für den Benutzer laden
+        $notifications = $this->getUserNotifications($userId);
+
+        // Benachrichtigungen zum Stream hinzufügen
+        foreach ($notifications as $notification) {
+            $result->addJsonEvent($notification, 'notification', $notification['id']);
+        }
+
+        return $result;
+    }
+
+    /**
+     * Gibt Benachrichtigungen für einen bestimmten Benutzer zurück
+     * In einer realen Anwendung würde diese Methode Daten aus einer Datenbank laden
+     */
+    private function getUserNotifications(int $userId): array
+    {
+        // Beispiel-Benachrichtigungen
+        return [
+            [
+                'id' => 'notif-' . uniqid(),
+                'type' => 'message',
+                'title' => 'Neue Nachricht',
+                'message' => 'Sie haben eine neue Nachricht erhalten',
+                'timestamp' => time() - 300 // Vor 5 Minuten
+            ],
+            [
+                'id' => 'notif-' . uniqid(),
+                'type' => 'system',
+                'title' => 'System-Update',
+                'message' => 'Das System wurde aktualisiert',
+                'timestamp' => time() - 3600 // Vor 1 Stunde
+            ]
+        ];
+    }
+
+    /**
+     * Stellt einen Live-Stream mit dynamischen Updates bereit
+     */
+    #[Auth]
+    #[Route(path: '/api/notifications/live', method: Method::GET)]
+    public function liveNotifications(): SseResult
+    {
+        // Erweiterte SSE-Konfiguration mit Callback
+        #$result = new SseResultWithCallback(Status::OK, 3000);
+
+        // Callback für dynamische Updates festlegen
+        $callback = function(SseStream $stream) {
+            // Simuliere neue Benachrichtigungen (mit 10% Wahrscheinlichkeit)
+            if (rand(1, 10) === 1) {
+                $notificationTypes = ['info', 'warning', 'update', 'message'];
+                $type = $notificationTypes[array_rand($notificationTypes)];
+
+                $notification = [
+                    'id' => 'live-notif-' . uniqid(),
+                    'type' => $type,
+                    'title' => 'Neue ' . ucfirst($type) . '-Benachrichtigung',
+                    'message' => 'Dies ist eine dynamisch generierte Benachrichtigung vom Typ ' . $type,
+                    'timestamp' => time()
+                ];
+
+                $stream->sendJson($notification, 'notification', $notification['id']);
+
+                // Kleine Pause nach dem Senden, um das Testszenario zu simulieren
+                sleep(1);
+            }
+        };
+
+        $result = new SseResult(
+            retryInterval: 500,
+            callback: $callback,
+            maxDuration: 300,
+            heartbeatInterval: 15,
+        );
+
+        // Initiale Verbindungsbestätigung
+        $result->addJsonEvent(
+            ['message' => 'Verbunden mit dem Live-Stream', 'timestamp' => time()],
+            'connected',
+            'live-' . uniqid()
+        );
+
+
+
+        return $result;
+    }
+}
diff --git a/src/Application/Http/Controllers/QrCodeController.php b/src/Application/Http/Controllers/QrCodeController.php
new file mode 100644
index 00000000..56861872
--- /dev/null
+++ b/src/Application/Http/Controllers/QrCodeController.php
@@ -0,0 +1,101 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Application\Http\Controllers;
+
+use App\Application\Service\QrCodeService;
+use App\Domain\QrCode\ValueObject\ErrorCorrectionLevel;
+use App\Framework\Attributes\Route;
+use App\Framework\Auth\Auth;
+use App\Framework\Http\Method;
+use App\Framework\Http\Status;
+use App\Framework\Http\Response;
+
+final class QrCodeController
+{
+    public function __construct(
+        private readonly QrCodeService $qrCodeService
+    ) {
+    }
+
+    /**
+     * Generiert einen QR-Code als SVG
+     */
+    #[Auth]
+    #[Route(path: '/api/qrcode/svg', method: Method::GET)]
+    public function generateSvg(): Response
+    {
+        $data = $_GET['data'] ?? 'https://example.com';
+        $errorLevel = $this->getErrorLevel($_GET['error_level'] ?? 'M');
+        $moduleSize = (int) ($_GET['module_size'] ?? 4);
+        $margin = (int) ($_GET['margin'] ?? 4);
+        $foreground = $_GET['foreground'] ?? '#000000';
+        $background = $_GET['background'] ?? '#FFFFFF';
+
+        $config = new QrCodeConfig($moduleSize, $margin, $foreground, $background);
+
+        $svg = $this->qrCodeService->generateSvg($data, $errorLevel, $config);
+
+        return new Response(
+            body: $svg,
+            status: Status::OK,
+            headers: ['Content-Type' => 'image/svg+xml']
+        );
+    }
+
+    /**
+     * Generiert einen QR-Code als PNG
+     */
+    #[Auth]
+    #[Route(path: '/api/qrcode/png', method: Method::GET)]
+    public function generatePng(): Response
+    {
+        $data = $_GET['data'] ?? 'https://example.com';
+        $errorLevel = $this->getErrorLevel($_GET['error_level'] ?? 'M');
+        $moduleSize = (int) ($_GET['module_size'] ?? 4);
+        $margin = (int) ($_GET['margin'] ?? 4);
+
+        $config = new QrCodeConfig($moduleSize, $margin);
+
+        $png = $this->qrCodeService->generatePng($data, $errorLevel, $config);
+
+        return new Response(
+            body: $png,
+            status: Status::OK,
+            headers: ['Content-Type' => 'image/png']
+        );
+    }
+
+    /**
+     * Generiert einen QR-Code als ASCII-Art
+     */
+    #[Auth]
+    #[Route(path: '/api/qrcode/ascii', method: Method::GET)]
+    public function generateAscii(): Response
+    {
+        $data = $_GET['data'] ?? 'https://example.com';
+        $errorLevel = $this->getErrorLevel($_GET['error_level'] ?? 'M');
+
+        $ascii = $this->qrCodeService->generateAscii($data, $errorLevel);
+
+        return new Response(
+            body: "<pre>$ascii</pre>",
+            status: Status::OK,
+            headers: ['Content-Type' => 'text/html; charset=utf-8']
+        );
+    }
+
+    /**
+     * Konvertiert einen String in ein ErrorCorrectionLevel-Enum
+     */
+    private function getErrorLevel(string $level): ErrorCorrectionLevel
+    {
+        return match (strtoupper($level)) {
+            'L' => ErrorCorrectionLevel::L,
+            'Q' => ErrorCorrectionLevel::Q,
+            'H' => ErrorCorrectionLevel::H,
+            default => ErrorCorrectionLevel::M,
+        };
+    }
+}
diff --git a/src/Application/Http/Smartlink.php b/src/Application/Http/Smartlink.php
new file mode 100644
index 00000000..a2d26de1
--- /dev/null
+++ b/src/Application/Http/Smartlink.php
@@ -0,0 +1,146 @@
+<?php
+
+namespace App\Application\Http;
+
+use App\Framework\Attributes\Route;
+use App\Framework\CommandBus\CommandBus;
+use App\Framework\Http\HeaderKey;
+use App\Framework\Http\Request;
+use App\Framework\Http\Method;
+use App\Framework\Http\Status;
+use App\Framework\Router\ActionResult;
+use App\Framework\Router\Result\ViewResult;
+use App\Framework\Router\Result\Redirect;
+use App\Framework\Meta\MetaData;
+use App\Framework\Smartlinks\Actions\ActionRegistry;
+use App\Framework\Smartlinks\Commands\ExecuteSmartlinkCommand;
+use App\Framework\Smartlinks\Commands\GenerateSmartlinkCommand;
+use App\Framework\Smartlinks\Commands\GenerateSmartlinkHandler;
+use App\Framework\Smartlinks\Services\SmartlinkService;
+use App\Framework\Smartlinks\SmartLinkToken;
+use App\Framework\Smartlinks\TokenAction;
+
+final readonly class Smartlink
+{
+    public function __construct(
+        private CommandBus $commandBus,
+        private ActionRegistry $actionRegistry,
+        private SmartlinkService $smartlinkService,
+        private GenerateSmartlinkHandler $handler,
+    ) {}
+
+    #[Route('/smartlink/{token}', method: Method::GET)]
+    #[Route('/smartlink/{token}', method: Method::POST)]
+    public function execute(string $token, Request $request): ActionResult
+    {
+        $command = new GenerateSmartlinkCommand(
+            action: new TokenAction('email_verification'),
+            payload: ['user_id' => 123, 'email' => 'user@example.com'],
+            baseUrl: 'https://localhost'
+        );
+
+        #debug($this->handler->handle($command));
+
+        try {
+            $smartlinkToken = new SmartlinkToken($token);
+
+            // Token validieren
+            $smartlinkData = $this->smartlinkService->validate($smartlinkToken);
+            if (!$smartlinkData) {
+                return new ViewResult(
+                    template: 'smartlinks-error',
+                    metaData: new MetaData(
+                        title: 'Ungültiger Link',
+                        description: 'Der Link ist ungültig oder abgelaufen'
+                    ),
+                    data: [
+                        'error' => 'Ungültiger oder abgelaufener Link',
+                        'error_code' => 'INVALID_TOKEN'
+                    ],
+                    status: Status::NOT_FOUND
+                );
+            }
+
+            // Action holen
+            $action = $this->actionRegistry->get($smartlinkData->action);
+            if (!$action) {
+                return new ViewResult(
+                    template: 'smartlinks-error',
+                    metaData: new MetaData(
+                        title: 'Unbekannte Aktion',
+                        description: 'Die angeforderte Aktion ist nicht verfügbar'
+                    ),
+                    data: [
+                        'error' => 'Unbekannte Aktion',
+                        'error_code' => 'UNKNOWN_ACTION'
+                    ],
+                    status: Status::BAD_REQUEST
+                );
+            }
+
+            // Context für Action vorbereiten
+            $context = [
+                'request_method' => $request->method->value,
+                'request_data' => $request->parsedBody ?? [],
+                'query_params' => $request->queryParameters ?? [],
+                #'ip_address' => $request->serverEnvironment->ipAddress?->value,
+                'user_agent' => $request->headers->getFirst(HeaderKey::USER_AGENT),
+                'headers' => $request->headers
+            ];
+
+            // Command ausführen
+            $command = new ExecuteSmartlinkCommand($smartlinkToken, $context);
+            $result = $this->commandBus->dispatch($command);
+
+            // Ergebnis verarbeiten
+            if (!$result->isSuccess()) {
+                return new ViewResult(
+                    template: $action->getErrorTemplate(),
+                    metaData: new MetaData(
+                        title: 'Fehler bei Ausführung',
+                        description: $result->message
+                    ),
+                    data: [
+                        'error' => $result->message,
+                        'errors' => $result->errors,
+                        'action' => $action->getName()
+                    ],
+                    status: Status::BAD_REQUEST
+                );
+            }
+
+            // Redirect oder View
+            if ($result->hasRedirect()) {
+                return new Redirect($result->redirectUrl);
+            }
+
+            return new ViewResult(
+                template: $action->getViewTemplate(),
+                metaData: new MetaData(
+                    title: $action->getName(),
+                    description: $result->message
+                ),
+                data: [
+                    'result' => $result,
+                    'action' => $action->getName(),
+                    'token' => $token
+                ]
+            );
+
+        } catch (\Exception $e) {
+            return new ViewResult(
+                template: 'smartlinks-error',
+                metaData: new MetaData(
+                    title: 'Systemfehler',
+                    description: 'Ein unerwarteter Fehler ist aufgetreten'
+                ),
+                data: [
+                    'error' => 'Ein Fehler ist aufgetreten',
+                    'error_code' => 'SYSTEM_ERROR',
+                    'debug_message' => $e->getMessage() // Nur für Development
+                ],
+                status: Status::INTERNAL_SERVER_ERROR
+            );
+        }
+    }
+}
diff --git a/src/Application/Http/templates/smartlinks-error.view.php b/src/Application/Http/templates/smartlinks-error.view.php
new file mode 100644
index 00000000..562f02f9
--- /dev/null
+++ b/src/Application/Http/templates/smartlinks-error.view.php
@@ -0,0 +1,9 @@
+<layout src="main"/>
+    <div class="error-container">
+        <h1>Fehler</h1>
+        <p>{{ error }}</p>
+
+        <?php if (isset($error_code)): ?>
+            <p><small>Fehlercode: <?= htmlspecialchars($error_code) ?></small></p>
+        <?php endif; ?>
+    </div>
diff --git a/src/Application/Media/AdaptiveVideoStream.php b/src/Application/Media/AdaptiveVideoStream.php
new file mode 100644
index 00000000..331c3057
--- /dev/null
+++ b/src/Application/Media/AdaptiveVideoStream.php
@@ -0,0 +1,48 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Application\Media;
+
+use App\Framework\Attributes\Route;
+use App\Framework\Http\Responses\AdaptiveStreamResponse;
+use App\Framework\Http\Responses\StreamResponse;
+use App\Framework\Http\Streaming\AdaptiveStreamingController;
+
+final readonly class AdaptiveVideoStream
+{
+    public function __construct(
+        private AdaptiveStreamingController $adaptiveStreamingController,
+    ) {
+
+    }
+
+    #[Route('/videos/{videoId}/manifest')]
+    public function manifestAutoFormat(string $videoId): AdaptiveStreamResponse
+    {
+        return $this->adaptiveStreamingController->manifest($videoId);
+    }
+
+    #[Route('/videos/{videoId}/manifest.m3u8')]
+    public function hlsManifest(string $videoId): AdaptiveStreamResponse
+    {
+        return $this->adaptiveStreamingController->hlsManifest($videoId);
+    }
+
+    #[Route('/videos/{videoId}/manifest.mpd')]
+    public function dashManifest(string $videoId): AdaptiveStreamResponse
+    {
+        return $this->adaptiveStreamingController->dashManifest($videoId);
+    }
+
+    #[Route('/videos/{videoId}/{quality}.m3u8')]
+    public function hlsMediaPlaylist(string $videoId, string $quality): AdaptiveStreamResponse
+    {
+        return $this->adaptiveStreamingController->hlsMediaPlaylist($videoId, $quality);
+    }
+
+    #[Route('/videos/{videoId}/{quality}/{segment}/')]
+    public function segment(string $videoId, string $quality, string $segment): StreamResponse
+    {
+        return $this->adaptiveStreamingController->segment($videoId, $quality, $segment);
+    }
+}
diff --git a/src/Application/Media/ShowImage.php b/src/Application/Media/ShowImage.php
new file mode 100644
index 00000000..2bd4edf9
--- /dev/null
+++ b/src/Application/Media/ShowImage.php
@@ -0,0 +1,93 @@
+<?php
+
+namespace App\Application\Media;
+
+use App\Domain\Media\ImageRepository;
+use App\Domain\Media\ImageVariantRepository;
+use App\Framework\Attributes\Route;
+use App\Framework\Core\PathProvider;
+use App\Framework\Router\Result\FileResult;
+
+final readonly class ShowImage
+{
+    public function __construct(
+        private PathProvider $pathProvider,
+        private ImageRepository $imageRepository,
+        private ImageVariantRepository $imageVariantRepository,
+    ) {}
+    #[Route('/images/{filename}')]
+    public function __invoke($filename): FileResult
+    {
+        $path = $this->pathProvider->resolvePath('storage/uploads/');
+
+        $image = $this->imageRepository->findByFilename($filename);
+
+        if($image === null) {
+            $image = $this->imageVariantRepository->findByFilename($filename);
+        }
+
+        if($image === null) {
+            throw new \Exception('Image not found');
+        }
+
+        $file = $image->path . $image->filename;
+
+        if (file_exists($file)) {
+            header('Content-Type: image/jpeg');
+            header('Content-Length: '.filesize($file));
+            // optional: Caching-Header
+            header('Cache-Control: public, max-age=86400');
+
+            // Hier: Download-Dateiname vorschlagen
+            // inline = im Browser anzeigen; attachment = Download erzwingen
+            header('Content-Disposition: inline; filename="' . $image->filename . '-2025"');
+            // oder
+            // header('Content-Disposition: attachment; filename="' . basename($filename) . '"');
+
+            // 1. Last-Modified & ETag (Conditional Requests)
+            $lastModified = gmdate('D, d M Y H:i:s', filemtime($file)).' GMT';
+            $eTag         = '"'.md5_file($file).'"';
+            header("Last-Modified: $lastModified");
+            header("ETag: $eTag");
+
+            // 304 Not Modified – wenn Browser-Cache gültig
+            if (
+                (isset($_SERVER['HTTP_IF_NONE_MATCH']) && trim($_SERVER['HTTP_IF_NONE_MATCH']) === $eTag) ||
+                (isset($_SERVER['HTTP_IF_MODIFIED_SINCE']) && $_SERVER['HTTP_IF_MODIFIED_SINCE'] === $lastModified)
+            ) {
+                http_response_code(304);
+                exit;
+            }
+
+            // 2. Expires (optional, zusätzlich zu Cache-Control)
+            $expireTime = gmdate('D, d M Y H:i:s', time() + 86400).' GMT';
+            header("Expires: $expireTime");
+
+            // 3. Accept-Ranges (für Partial-Requests / Resuming)
+            header('Accept-Ranges: bytes');
+
+            // 4. Vary (bei Content-Negotiation, z. B. für WebP)
+            header('Vary: Accept');
+
+            // 5. Security-Header
+            // Verhindert MIME-Sniffing
+            header('X-Content-Type-Options: nosniff');
+            // Schutz gegen Clickjacking (falls du Bilder in iframes erlauben willst, ggf. anpassen)
+            header('X-Frame-Options: SAMEORIGIN');
+            // Referrer-Policy für Bildanfragen
+            header('Referrer-Policy: no-referrer-when-downgrade');
+
+            // 6. Content-Security-Policy (CSP) – strengere Kontrolle, wenn du das Bild per <img> einbindest
+            // Hier als Beispiel nur für Bilder aus eigenem Domain
+            header("Content-Security-Policy: default-src 'self'; img-src 'self';");
+
+            readfile($file);
+
+            exit;
+        }
+
+
+
+        return new FileResult($file);
+    }
+}
diff --git a/src/Application/Media/ShowVideo.php b/src/Application/Media/ShowVideo.php
new file mode 100644
index 00000000..c807e790
--- /dev/null
+++ b/src/Application/Media/ShowVideo.php
@@ -0,0 +1,45 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Application\Media;
+
+use App\Framework\Attributes\Route;
+use App\Framework\Core\PathProvider;
+use App\Framework\Http\Request;
+use App\Framework\Http\Responses\MediaType;
+use App\Framework\Http\Responses\StreamResponse;
+use App\Framework\Http\Streaming\MimeTypeDetector;
+use App\Framework\Http\Streaming\RangeParser;
+
+final readonly class ShowVideo
+{
+    public function __construct(
+        private PathProvider $pathProvider,
+    ) {}
+
+    #[Route('/videos/{filename}')]
+    public function __invoke(string $filename): StreamResponse
+    {
+        $filePath = $this->pathProvider->resolvePath('/storage/uploads/videos/'.$filename);
+
+        #dd($path);
+
+        #$filePath = "/media/{$filename}";
+        $fileSize = filesize($filePath);
+        $mimeType = MimeTypeDetector::detect($filePath);
+
+        $range = null;
+        if (isset($_SERVER['HTTP_RANGE'])) {
+            $range = RangeParser::parseRange($_SERVER['HTTP_RANGE'], $fileSize);
+        }
+
+        return new StreamResponse(
+            filePath : $filePath,
+            fileSize : $fileSize,
+            mimeType : $mimeType,
+            range    : $range,
+            mediaType: MediaType::fromMimeType($mimeType)
+        );
+
+    }
+}
diff --git a/src/Application/Newsletter/SignUp/EventHandlerExample.php b/src/Application/Newsletter/SignUp/EventHandlerExample.php
new file mode 100644
index 00000000..c48e9275
--- /dev/null
+++ b/src/Application/Newsletter/SignUp/EventHandlerExample.php
@@ -0,0 +1,29 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Application\Newsletter\SignUp;
+
+use App\Framework\EventBus\EventHandler;
+
+/**
+ * Beispiel für einen Event-Handler für das UserWasSignedUp-Event
+ */
+final readonly class EventHandlerExample
+{
+    /**
+     * Behandelt das UserWasSignedUp-Event
+     *
+     * @param UserWasSignedUp $event Das Event
+     * @return void
+     */
+    #[EventHandler]
+    public function handleUserSignedUp(UserWasSignedUp $event): void
+    {
+        // Hier kann die Verarbeitung des Events implementiert werden
+        // Zum Beispiel: E-Mail senden, Statistiken aktualisieren, etc.
+
+        error_log($event->email . ' wurde für den Newsletter angemeldet.');
+
+        #var_dump($event);
+    }
+}
diff --git a/src/Application/Newsletter/SignUp/NewsletterSignup.php b/src/Application/Newsletter/SignUp/NewsletterSignup.php
new file mode 100644
index 00000000..685ef107
--- /dev/null
+++ b/src/Application/Newsletter/SignUp/NewsletterSignup.php
@@ -0,0 +1,42 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Application\Newsletter\SignUp;
+
+use App\Framework\Attributes\Route;
+use App\Framework\CommandBus\CommandBus;
+use App\Framework\CommandBus\DefaultCommandBus;
+use App\Framework\Http\Method;
+use App\Framework\Http\Status;
+use App\Framework\Router\Result\ContentNegotiationResult;
+use App\Framework\Router\Result\JsonResult;
+
+final readonly class NewsletterSignup
+{
+    public function __construct(
+        public CommandBus $commandBus,
+    ) {}
+
+    #[Route(path: '/newsletter/register', method: Method::POST)]
+    public function __invoke(NewsletterSignupRequest $request): ContentNegotiationResult
+    {
+        // Den internen Command ausführen
+        $command = new SignupUserToNewsletter($request->name, $request->email);
+
+        $result = $this->commandBus->dispatch($command);
+
+
+        // Hier könnten Sie das Ergebnis weiterverarbeiten oder loggen
+        return new ContentNegotiationResult(
+            jsonPayload: [
+                'success' => true,
+                'message' => 'Anmeldung erfolgreich!',
+                'data' => [
+                    $request->name,
+                    $request->email,
+                ],
+            ],
+            redirectTo: '/'
+        );
+    }
+}
diff --git a/src/Application/Newsletter/SignUp/NewsletterSignupHandler.php b/src/Application/Newsletter/SignUp/NewsletterSignupHandler.php
new file mode 100644
index 00000000..7c03d5d9
--- /dev/null
+++ b/src/Application/Newsletter/SignUp/NewsletterSignupHandler.php
@@ -0,0 +1,37 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Application\Newsletter\SignUp;
+
+use App\Framework\CommandBus\CommandHandler;
+use App\Framework\EventBus\EventBus;
+use App\Infrastructure\Api\RapidMailClient;
+use Archive\Config\ApiConfig;
+
+final readonly class NewsletterSignupHandler
+{
+    public function __construct(
+        private EventBus $eventBus,
+    ) {}
+
+    #[CommandHandler]
+    public function __invoke(SignupUserToNewsletter $command):void
+    {
+        // RapidMail-Client erstellen und konfigurieren
+        $client = new RapidMailClient(
+            ApiConfig::RAPIDMAIL_USERNAME->value,
+            ApiConfig::RAPIDMAIL_PASSWORD->value
+        );
+
+        // Abonnent zur Liste hinzufügen
+        $result = $client->addRecipient(
+            $command->name,
+            $command->email,
+            ApiConfig::getRapidmailListId()
+        );
+
+        error_log('CommandHandler für: '.$command->email);;
+
+        $this->eventBus->dispatch(new UserWasSignedUp($command->email));
+    }
+}
diff --git a/src/Application/Newsletter/SignUp/NewsletterSignupRequest.php b/src/Application/Newsletter/SignUp/NewsletterSignupRequest.php
new file mode 100644
index 00000000..0ec71d06
--- /dev/null
+++ b/src/Application/Newsletter/SignUp/NewsletterSignupRequest.php
@@ -0,0 +1,21 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Application\Newsletter\SignUp;
+
+use App\Framework\Http\ControllerRequest;
+use App\Framework\Validation\Rules\Email;
+use App\Framework\Validation\Rules\IsTrue;
+use App\Framework\Validation\Rules\Required;
+use App\Framework\Validation\Rules\StringLength;
+
+final readonly class NewsletterSignupRequest implements ControllerRequest
+{
+    #[Email]
+    public string $email;
+
+    #[StringLength(min: 3, max: 255)]
+    public string $name;
+    #[IsTrue]
+    public bool $consent;
+}
diff --git a/src/Application/Newsletter/SignUp/SignupUserToNewsletter.php b/src/Application/Newsletter/SignUp/SignupUserToNewsletter.php
new file mode 100644
index 00000000..6e3fd1b7
--- /dev/null
+++ b/src/Application/Newsletter/SignUp/SignupUserToNewsletter.php
@@ -0,0 +1,15 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Application\Newsletter\SignUp;
+
+use App\Framework\CommandBus\ShouldQueue;
+
+#[ShouldQueue]
+final readonly class SignupUserToNewsletter
+{
+    public function __construct(
+        public string $name,
+        public string $email,
+    ) {}
+}
diff --git a/src/Application/Newsletter/SignUp/UserWasSignedUp.php b/src/Application/Newsletter/SignUp/UserWasSignedUp.php
new file mode 100644
index 00000000..21782339
--- /dev/null
+++ b/src/Application/Newsletter/SignUp/UserWasSignedUp.php
@@ -0,0 +1,15 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Application\Newsletter\SignUp;
+
+/**
+ * Event, das ausgelöst wird, wenn ein Benutzer für den Newsletter angemeldet wurde
+ */
+final readonly class UserWasSignedUp
+{
+    public function __construct(public string $email)
+    {
+        // Event-Daten können hier hinzugefügt werden
+    }
+}
diff --git a/src/Application/NewsletterSignup.http b/src/Application/NewsletterSignup.http
new file mode 100644
index 00000000..9d02c66f
--- /dev/null
+++ b/src/Application/NewsletterSignup.http
@@ -0,0 +1,8 @@
+### POST request to example server
+POST https://localhost/newsletter/register
+Content-Type: application/x-www-form-urlencoded
+
+email = michael.schiemer@gmail.com &
+consent = 1
+
+###
diff --git a/src/Application/Security/Events/Access/CsrfViolation.php b/src/Application/Security/Events/Access/CsrfViolation.php
new file mode 100644
index 00000000..0b8e3638
--- /dev/null
+++ b/src/Application/Security/Events/Access/CsrfViolation.php
@@ -0,0 +1,21 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Application\Security\Events\Access;
+
+use App\Application\Security\SecurityEvent;
+use App\Application\Security\SecurityEventType;
+
+final class CsrfViolation implements SecurityEvent
+{
+    public function __construct(
+        public readonly string $requestPath,
+        public readonly string $method,
+    ) {}
+
+    public SecurityEventType $type {
+        get {
+            return SecurityEventType::CSRF_VIOLATION;
+        }
+    }
+}
diff --git a/src/Application/Security/Events/Auth/AccountLockedEvent.php b/src/Application/Security/Events/Auth/AccountLockedEvent.php
new file mode 100644
index 00000000..c7755b46
--- /dev/null
+++ b/src/Application/Security/Events/Auth/AccountLockedEvent.php
@@ -0,0 +1,51 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Application\Security\Events\Auth;
+
+use App\Application\Security\ValueObjects\{OWASPEventIdentifier, OWASPLogLevel};
+
+final class AccountLockedEvent
+{
+    public function __construct(
+        public readonly string $email,
+        public readonly string $reason,
+        public readonly int $failedAttempts
+    ) {}
+
+    public function getOWASPEventIdentifier(): OWASPEventIdentifier
+    {
+        return OWASPEventIdentifier::accountLocked($this->maskEmail($this->email));
+    }
+
+    public function getOWASPLogLevel(): OWASPLogLevel
+    {
+        return OWASPLogLevel::ERROR;
+    }
+
+    public function getDescription(): string
+    {
+        return "Account {$this->maskEmail($this->email)} locked";
+    }
+
+    public function getEventData(): array
+    {
+        return [
+            'username' => $this->maskEmail($this->email),
+            'lock_reason' => $this->reason,
+            'failed_attempts' => $this->failedAttempts
+        ];
+    }
+
+    private function maskEmail(string $email): string
+    {
+        if (!filter_var($email, FILTER_VALIDATE_EMAIL)) {
+            return $email;
+        }
+
+        [$local, $domain] = explode('@', $email, 2);
+        $maskedLocal = substr($local, 0, 2) . str_repeat('*', max(0, strlen($local) - 2));
+
+        return $maskedLocal . '@' . $domain;
+    }
+}
diff --git a/src/Application/Security/Events/Auth/AuthenticationFailedEvent.php b/src/Application/Security/Events/Auth/AuthenticationFailedEvent.php
new file mode 100644
index 00000000..ccebd180
--- /dev/null
+++ b/src/Application/Security/Events/Auth/AuthenticationFailedEvent.php
@@ -0,0 +1,51 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Application\Security\Events\Auth;
+
+use App\Application\Security\{OWASPSecurityEvent};
+use App\Application\Security\ValueObjects\{OWASPEventIdentifier, OWASPLogLevel, MaskedEmail};
+
+final class AuthenticationFailedEvent implements OWASPSecurityEvent
+{
+    private MaskedEmail $maskedEmail;
+
+    public function __construct(
+        public readonly string $email,
+        public readonly ?string $reason = null,
+        public readonly int $failedAttempts = 1
+    ) {
+        $this->maskedEmail = MaskedEmail::fromString($this->email);
+    }
+
+    public function getOWASPEventIdentifier(): OWASPEventIdentifier
+    {
+        return OWASPEventIdentifier::authenticationFailure($this->maskedEmail->toString());
+    }
+
+    public function getOWASPLogLevel(): OWASPLogLevel
+    {
+        return OWASPLogLevel::WARN;
+    }
+
+    public function getDescription(): string
+    {
+        return "User {$this->maskedEmail->toString()} login failed" .
+               ($this->reason ? " - {$this->reason}" : '');
+    }
+
+    public function getEventData(): array
+    {
+        return [
+            'email' => $this->maskedEmail->toString(),
+            'reason' => $this->reason,
+            'failed_attempts' => $this->failedAttempts,
+            'failure_reason' => $this->reason ?? 'invalid_credentials'
+        ];
+    }
+
+    public function getMaskedEmail(): MaskedEmail
+    {
+        return $this->maskedEmail;
+    }
+}
diff --git a/src/Application/Security/Events/Auth/AuthenticationSuccessEvent.php b/src/Application/Security/Events/Auth/AuthenticationSuccessEvent.php
new file mode 100644
index 00000000..2a46354f
--- /dev/null
+++ b/src/Application/Security/Events/Auth/AuthenticationSuccessEvent.php
@@ -0,0 +1,49 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Application\Security\Events\Auth;
+
+use App\Application\Security\{OWASPSecurityEvent};
+use App\Application\Security\ValueObjects\{OWASPEventIdentifier, OWASPLogLevel, MaskedEmail};
+
+final class AuthenticationSuccessEvent implements OWASPSecurityEvent
+{
+    private MaskedEmail $maskedEmail;
+
+    public function __construct(
+        public readonly string $email,
+        public readonly string $sessionId,
+        public readonly ?string $method = 'password'
+    ) {
+        $this->maskedEmail = MaskedEmail::fromString($this->email);
+    }
+
+    public function getOWASPEventIdentifier(): OWASPEventIdentifier
+    {
+        return OWASPEventIdentifier::authenticationSuccess($this->maskedEmail->toString());
+    }
+
+    public function getOWASPLogLevel(): OWASPLogLevel
+    {
+        return OWASPLogLevel::INFO;
+    }
+
+    public function getDescription(): string
+    {
+        return "User {$this->maskedEmail->toString()} login successfully";
+    }
+
+    public function getEventData(): array
+    {
+        return [
+            'username' => $this->maskedEmail->toString(),
+            'session_id' => hash('sha256', $this->sessionId), // Session-ID hashen für Sicherheit
+            'method' => $this->method
+        ];
+    }
+
+    public function getMaskedEmail(): MaskedEmail
+    {
+        return $this->maskedEmail;
+    }
+}
diff --git a/src/Application/Security/Events/Auth/LoginFailed.php b/src/Application/Security/Events/Auth/LoginFailed.php
new file mode 100644
index 00000000..fd33848d
--- /dev/null
+++ b/src/Application/Security/Events/Auth/LoginFailed.php
@@ -0,0 +1,20 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Application\Security\Events\Auth;
+
+use App\Application\Security\SecurityEvent;
+use App\Application\Security\SecurityEventType;
+
+final class LoginFailed implements SecurityEvent
+{
+    public function __construct(
+        public string $email
+    ) {}
+
+    public SecurityEventType $type {
+        get {
+            return SecurityEventType::LOGIN_FAILED;
+        }
+    }
+}
diff --git a/src/Application/Security/Events/Auth/PasswordChangedEvent.php b/src/Application/Security/Events/Auth/PasswordChangedEvent.php
new file mode 100644
index 00000000..e7a4845c
--- /dev/null
+++ b/src/Application/Security/Events/Auth/PasswordChangedEvent.php
@@ -0,0 +1,49 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Application\Security\Events\Auth;
+
+use App\Application\Security\ValueObjects\{OWASPEventIdentifier, OWASPLogLevel};
+
+final class PasswordChangedEvent
+{
+    public function __construct(
+        public readonly string $email,
+        public readonly string $method = 'self_service'
+    ) {}
+
+    public function getOWASPEventIdentifier(): OWASPEventIdentifier
+    {
+        return OWASPEventIdentifier::passwordChange($this->maskEmail($this->email));
+    }
+
+    public function getOWASPLogLevel(): OWASPLogLevel
+    {
+        return OWASPLogLevel::INFO;
+    }
+
+    public function getDescription(): string
+    {
+        return "User {$this->maskEmail($this->email)} changed password";
+    }
+
+    public function getEventData(): array
+    {
+        return [
+            'username' => $this->maskEmail($this->email),
+            'change_method' => $this->method
+        ];
+    }
+
+    private function maskEmail(string $email): string
+    {
+        if (!filter_var($email, FILTER_VALIDATE_EMAIL)) {
+            return $email;
+        }
+
+        [$local, $domain] = explode('@', $email, 2);
+        $maskedLocal = substr($local, 0, 2) . str_repeat('*', max(0, strlen($local) - 2));
+
+        return $maskedLocal . '@' . $domain;
+    }
+}
diff --git a/src/Application/Security/Events/Auth/SessionTerminatedEvent.php b/src/Application/Security/Events/Auth/SessionTerminatedEvent.php
new file mode 100644
index 00000000..6a02742f
--- /dev/null
+++ b/src/Application/Security/Events/Auth/SessionTerminatedEvent.php
@@ -0,0 +1,49 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Application\Security\Events\Auth;
+
+use App\Application\Security\{OWASPSecurityEvent};
+use App\Application\Security\ValueObjects\{OWASPEventIdentifier, OWASPLogLevel, MaskedEmail};
+
+final class SessionTerminatedEvent implements OWASPSecurityEvent
+{
+    private MaskedEmail $maskedEmail;
+
+    public function __construct(
+        public readonly string $email,
+        public readonly string $sessionId,
+        public readonly string $reason = 'logout'
+    ) {
+        $this->maskedEmail = MaskedEmail::fromString($this->email);
+    }
+
+    public function getOWASPEventIdentifier(): OWASPEventIdentifier
+    {
+        return OWASPEventIdentifier::sessionTermination($this->maskedEmail->toString());
+    }
+
+    public function getOWASPLogLevel(): OWASPLogLevel
+    {
+        return OWASPLogLevel::INFO;
+    }
+
+    public function getDescription(): string
+    {
+        return "User {$this->maskedEmail->toString()} logged out";
+    }
+
+    public function getEventData(): array
+    {
+        return [
+            'username' => $this->maskedEmail->toString(),
+            'session_id' => hash('sha256', $this->sessionId),
+            'termination_reason' => $this->reason
+        ];
+    }
+
+    public function getMaskedEmail(): MaskedEmail
+    {
+        return $this->maskedEmail;
+    }
+}
diff --git a/src/Application/Security/Events/Authorization/AccessDeniedEvent.php b/src/Application/Security/Events/Authorization/AccessDeniedEvent.php
new file mode 100644
index 00000000..1daf540f
--- /dev/null
+++ b/src/Application/Security/Events/Authorization/AccessDeniedEvent.php
@@ -0,0 +1,56 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Application\Security\Events\Authorization;
+
+use App\Application\Security\ValueObjects\{OWASPEventIdentifier, OWASPLogLevel};
+
+final class AccessDeniedEvent
+{
+    public function __construct(
+        public readonly string $email,
+        public readonly string $resource,
+        public readonly string $action,
+        public readonly ?string $requiredPermission = null
+    ) {}
+
+    public function getOWASPEventIdentifier(): OWASPEventIdentifier
+    {
+        return OWASPEventIdentifier::authorizationFailure(
+            $this->maskEmail($this->email),
+            $this->resource
+        );
+    }
+
+    public function getOWASPLogLevel(): OWASPLogLevel
+    {
+        return OWASPLogLevel::WARN;
+    }
+
+    public function getDescription(): string
+    {
+        return "Access denied for user {$this->maskEmail($this->email)} to resource {$this->resource}";
+    }
+
+    public function getEventData(): array
+    {
+        return [
+            'username' => $this->maskEmail($this->email),
+            'resource' => $this->resource,
+            'action' => $this->action,
+            'required_permission' => $this->requiredPermission
+        ];
+    }
+
+    private function maskEmail(string $email): string
+    {
+        if (!filter_var($email, FILTER_VALIDATE_EMAIL)) {
+            return $email;
+        }
+
+        [$local, $domain] = explode('@', $email, 2);
+        $maskedLocal = substr($local, 0, 2) . str_repeat('*', max(0, strlen($local) - 2));
+
+        return $maskedLocal . '@' . $domain;
+    }
+}
diff --git a/src/Application/Security/Events/Authorization/PrivilegeEscalationEvent.php b/src/Application/Security/Events/Authorization/PrivilegeEscalationEvent.php
new file mode 100644
index 00000000..f1a2088e
--- /dev/null
+++ b/src/Application/Security/Events/Authorization/PrivilegeEscalationEvent.php
@@ -0,0 +1,58 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Application\Security\Events\Authorization;
+
+use App\Application\Security\{OWASPSecurityEvent};
+use App\Application\Security\ValueObjects\{OWASPEventIdentifier, OWASPLogLevel, MaskedEmail};
+
+final class PrivilegeEscalationEvent implements OWASPSecurityEvent
+{
+    private MaskedEmail $maskedEmail;
+
+    public function __construct(
+        public readonly string $email,
+        public readonly string $fromRole,
+        public readonly string $toRole,
+        public readonly string $method,
+        public readonly bool $successful = false
+    ) {
+        $this->maskedEmail = MaskedEmail::fromString($this->email);
+    }
+
+    public function getOWASPEventIdentifier(): OWASPEventIdentifier
+    {
+        return OWASPEventIdentifier::privilegeEscalation(
+            $this->maskedEmail->toString(),
+            $this->fromRole,
+            $this->toRole
+        );
+    }
+
+    public function getOWASPLogLevel(): OWASPLogLevel
+    {
+        return OWASPLogLevel::FATAL;
+    }
+
+    public function getDescription(): string
+    {
+        $status = $this->successful ? 'successful' : 'attempted';
+        return "Privilege escalation {$status} by user {$this->maskedEmail->toString()}";
+    }
+
+    public function getEventData(): array
+    {
+        return [
+            'username' => $this->maskedEmail->toString(),
+            'from_role' => $this->fromRole,
+            'to_role' => $this->toRole,
+            'escalation_method' => $this->method,
+            'successful' => $this->successful
+        ];
+    }
+
+    public function getMaskedEmail(): MaskedEmail
+    {
+        return $this->maskedEmail;
+    }
+}
diff --git a/src/Application/Security/Events/Crypto/CryptographicFailureEvent.php b/src/Application/Security/Events/Crypto/CryptographicFailureEvent.php
new file mode 100644
index 00000000..6af569ed
--- /dev/null
+++ b/src/Application/Security/Events/Crypto/CryptographicFailureEvent.php
@@ -0,0 +1,51 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Application\Security\Events\Crypto;
+
+use App\Application\Security\{OWASPSecurityEvent};
+use App\Application\Security\ValueObjects\{OWASPEventIdentifier, OWASPLogLevel, MaskedEmail};
+
+final class CryptographicFailureEvent implements OWASPSecurityEvent
+{
+    private ?MaskedEmail $maskedEmail;
+
+    public function __construct(
+        public readonly string $operation,
+        public readonly string $algorithm,
+        public readonly string $errorMessage,
+        public readonly ?string $email = null
+    ) {
+        $this->maskedEmail = $this->email ? MaskedEmail::fromString($this->email) : null;
+    }
+
+    public function getOWASPEventIdentifier(): OWASPEventIdentifier
+    {
+        return OWASPEventIdentifier::cryptographicFailure($this->operation);
+    }
+
+    public function getOWASPLogLevel(): OWASPLogLevel
+    {
+        return OWASPLogLevel::ERROR;
+    }
+
+    public function getDescription(): string
+    {
+        return "Cryptographic failure in {$this->operation}";
+    }
+
+    public function getEventData(): array
+    {
+        return [
+            'operation' => $this->operation,
+            'algorithm' => $this->algorithm,
+            'error_message' => $this->errorMessage,
+            'username' => $this->maskedEmail?->toString() ?? 'system'
+        ];
+    }
+
+    public function getMaskedEmail(): ?MaskedEmail
+    {
+        return $this->maskedEmail;
+    }
+}
diff --git a/src/Application/Security/Events/File/SuspiciousFileUploadEvent.php b/src/Application/Security/Events/File/SuspiciousFileUploadEvent.php
new file mode 100644
index 00000000..e7be8bc3
--- /dev/null
+++ b/src/Application/Security/Events/File/SuspiciousFileUploadEvent.php
@@ -0,0 +1,58 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Application\Security\Events\File;
+
+use App\Application\Security\{OWASPSecurityEvent};
+use App\Application\Security\ValueObjects\{OWASPEventIdentifier, OWASPLogLevel, MaskedEmail};
+
+final class SuspiciousFileUploadEvent implements OWASPSecurityEvent
+{
+    private ?MaskedEmail $maskedEmail;
+
+    public function __construct(
+        public readonly string $filename,
+        public readonly string $mimeType,
+        public readonly int $fileSize,
+        public readonly string $suspicionReason,
+        public readonly ?string $email = null
+    ) {
+        $this->maskedEmail = $this->email ? MaskedEmail::fromString($this->email) : null;
+    }
+
+    public function getOWASPEventIdentifier(): OWASPEventIdentifier
+    {
+        return OWASPEventIdentifier::fileUploadFailure($this->filename);
+    }
+
+    public function getOWASPLogLevel(): OWASPLogLevel
+    {
+        return OWASPLogLevel::ERROR;
+    }
+
+    public function getDescription(): string
+    {
+        return "Suspicious file upload: {$this->filename}";
+    }
+
+    public function getEventData(): array
+    {
+        return [
+            'filename' => $this->sanitizeFilename($this->filename),
+            'mime_type' => $this->mimeType,
+            'file_size' => $this->fileSize,
+            'suspicion_reason' => $this->suspicionReason,
+            'username' => $this->maskedEmail?->toString() ?? 'anonymous'
+        ];
+    }
+
+    public function getMaskedEmail(): ?MaskedEmail
+    {
+        return $this->maskedEmail;
+    }
+
+    private function sanitizeFilename(string $filename): string
+    {
+        return preg_replace('/[^\w\.\-]/', '_', $filename);
+    }
+}
diff --git a/src/Application/Security/Events/Input/InputValidationFailureEvent.php b/src/Application/Security/Events/Input/InputValidationFailureEvent.php
new file mode 100644
index 00000000..e2b47069
--- /dev/null
+++ b/src/Application/Security/Events/Input/InputValidationFailureEvent.php
@@ -0,0 +1,58 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Application\Security\Events\Input;
+
+use App\Application\Security\{OWASPSecurityEvent};
+use App\Application\Security\ValueObjects\{OWASPEventIdentifier, OWASPLogLevel, MaskedEmail};
+
+final class InputValidationFailureEvent implements OWASPSecurityEvent
+{
+    private ?MaskedEmail $maskedEmail;
+
+    public function __construct(
+        public readonly string $fieldName,
+        public readonly string $invalidValue,
+        public readonly string $validationRule,
+        public readonly ?string $email = null
+    ) {
+        $this->maskedEmail = $this->email ? MaskedEmail::fromString($this->email) : null;
+    }
+
+    public function getOWASPEventIdentifier(): OWASPEventIdentifier
+    {
+        return OWASPEventIdentifier::inputValidationFailure($this->fieldName);
+    }
+
+    public function getOWASPLogLevel(): OWASPLogLevel
+    {
+        return OWASPLogLevel::WARN;
+    }
+
+    public function getDescription(): string
+    {
+        return "Input validation failure for field {$this->fieldName}";
+    }
+
+    public function getEventData(): array
+    {
+        return [
+            'field_name' => $this->fieldName,
+            'invalid_value' => $this->sanitizeForLog($this->invalidValue),
+            'validation_rule' => $this->validationRule,
+            'username' => $this->maskedEmail?->toString() ?? 'anonymous'
+        ];
+    }
+
+    public function getMaskedEmail(): ?MaskedEmail
+    {
+        return $this->maskedEmail;
+    }
+
+    private function sanitizeForLog(string $value): string
+    {
+        // Maximal 100 Zeichen und gefährliche Zeichen entfernen
+        $sanitized = substr($value, 0, 100);
+        return preg_replace('/[^\w\s\.\-@]/', '***', $sanitized);
+    }
+}
diff --git a/src/Application/Security/Events/Input/MaliciousInputDetectedEvent.php b/src/Application/Security/Events/Input/MaliciousInputDetectedEvent.php
new file mode 100644
index 00000000..5c2340ab
--- /dev/null
+++ b/src/Application/Security/Events/Input/MaliciousInputDetectedEvent.php
@@ -0,0 +1,51 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Application\Security\Events\Input;
+
+use App\Application\Security\{OWASPSecurityEvent};
+use App\Application\Security\ValueObjects\{OWASPEventIdentifier, OWASPLogLevel, MaskedEmail};
+
+final class MaliciousInputDetectedEvent implements OWASPSecurityEvent
+{
+    private ?MaskedEmail $maskedEmail;
+
+    public function __construct(
+        public readonly string $fieldName,
+        public readonly string $attackPattern,
+        public readonly string $sanitizedValue,
+        public readonly ?string $email = null
+    ) {
+        $this->maskedEmail = $this->email ? MaskedEmail::fromString($this->email) : null;
+    }
+
+    public function getOWASPEventIdentifier(): OWASPEventIdentifier
+    {
+        return OWASPEventIdentifier::maliciousInput($this->attackPattern);
+    }
+
+    public function getOWASPLogLevel(): OWASPLogLevel
+    {
+        return OWASPLogLevel::ERROR;
+    }
+
+    public function getDescription(): string
+    {
+        return "Malicious input detected: {$this->attackPattern}";
+    }
+
+    public function getEventData(): array
+    {
+        return [
+            'field_name' => $this->fieldName,
+            'attack_pattern' => $this->attackPattern,
+            'sanitized_value' => $this->sanitizedValue,
+            'username' => $this->maskedEmail?->toString() ?? 'anonymous'
+        ];
+    }
+
+    public function getMaskedEmail(): ?MaskedEmail
+    {
+        return $this->maskedEmail;
+    }
+}
diff --git a/src/Application/Security/Events/Input/SqlInjectionAttemptEvent.php b/src/Application/Security/Events/Input/SqlInjectionAttemptEvent.php
new file mode 100644
index 00000000..e4855865
--- /dev/null
+++ b/src/Application/Security/Events/Input/SqlInjectionAttemptEvent.php
@@ -0,0 +1,57 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Application\Security\Events\Input;
+
+use App\Application\Security\{OWASPSecurityEvent};
+use App\Application\Security\ValueObjects\{OWASPEventIdentifier, OWASPLogLevel, MaskedEmail};
+
+final class SqlInjectionAttemptEvent implements OWASPSecurityEvent
+{
+    private ?MaskedEmail $maskedEmail;
+
+    public function __construct(
+        public readonly string $attackPayload,
+        public readonly string $targetField,
+        public readonly string $detectionMethod,
+        public readonly ?string $email = null
+    ) {
+        $this->maskedEmail = $this->email ? MaskedEmail::fromString($this->email) : null;
+    }
+
+    public function getOWASPEventIdentifier(): OWASPEventIdentifier
+    {
+        return OWASPEventIdentifier::maliciousInput('sql_injection');
+    }
+
+    public function getOWASPLogLevel(): OWASPLogLevel
+    {
+        return OWASPLogLevel::ERROR;
+    }
+
+    public function getDescription(): string
+    {
+        return "SQL injection attempt detected";
+    }
+
+    public function getEventData(): array
+    {
+        return [
+            'attack_payload' => $this->sanitizePayload($this->attackPayload),
+            'target_field' => $this->targetField,
+            'detection_method' => $this->detectionMethod,
+            'username' => $this->maskedEmail?->toString() ?? 'anonymous'
+        ];
+    }
+
+    public function getMaskedEmail(): ?MaskedEmail
+    {
+        return $this->maskedEmail;
+    }
+
+    private function sanitizePayload(string $payload): string
+    {
+        // SQL-Injection-Payload nur teilweise loggen für Analyse
+        return substr(preg_replace('/[^\w\s\'\";=\-\(\)]/', '***', $payload), 0, 200);
+    }
+}
diff --git a/src/Application/Security/Events/Input/XssAttemptEvent.php b/src/Application/Security/Events/Input/XssAttemptEvent.php
new file mode 100644
index 00000000..15e03358
--- /dev/null
+++ b/src/Application/Security/Events/Input/XssAttemptEvent.php
@@ -0,0 +1,57 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Application\Security\Events\Input;
+
+use App\Application\Security\{OWASPSecurityEvent};
+use App\Application\Security\ValueObjects\{OWASPEventIdentifier, OWASPLogLevel, MaskedEmail};
+
+final class XssAttemptEvent implements OWASPSecurityEvent
+{
+    private ?MaskedEmail $maskedEmail;
+
+    public function __construct(
+        public readonly string $attackPayload,
+        public readonly string $targetField,
+        public readonly string $xssType,
+        public readonly ?string $email = null
+    ) {
+        $this->maskedEmail = $this->email ? MaskedEmail::fromString($this->email) : null;
+    }
+
+    public function getOWASPEventIdentifier(): OWASPEventIdentifier
+    {
+        return OWASPEventIdentifier::maliciousInput('xss_attempt');
+    }
+
+    public function getOWASPLogLevel(): OWASPLogLevel
+    {
+        return OWASPLogLevel::ERROR;
+    }
+
+    public function getDescription(): string
+    {
+        return "XSS attempt detected: {$this->xssType}";
+    }
+
+    public function getEventData(): array
+    {
+        return [
+            'attack_payload' => $this->sanitizePayload($this->attackPayload),
+            'target_field' => $this->targetField,
+            'xss_type' => $this->xssType,
+            'username' => $this->maskedEmail?->toString() ?? 'anonymous'
+        ];
+    }
+
+    public function getMaskedEmail(): ?MaskedEmail
+    {
+        return $this->maskedEmail;
+    }
+
+    private function sanitizePayload(string $payload): string
+    {
+        // HTML-Tags entfernen aber Struktur beibehalten für Analyse
+        return substr(htmlspecialchars($payload, ENT_QUOTES, 'UTF-8'), 0, 200);
+    }
+}
diff --git a/src/Application/Security/Events/Network/SuspiciousNetworkActivityEvent.php b/src/Application/Security/Events/Network/SuspiciousNetworkActivityEvent.php
new file mode 100644
index 00000000..84112f1a
--- /dev/null
+++ b/src/Application/Security/Events/Network/SuspiciousNetworkActivityEvent.php
@@ -0,0 +1,53 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Application\Security\Events\Network;
+
+use App\Application\Security\{OWASPSecurityEvent};
+use App\Application\Security\ValueObjects\{OWASPEventIdentifier, OWASPLogLevel, MaskedEmail};
+
+final class SuspiciousNetworkActivityEvent implements OWASPSecurityEvent
+{
+    private ?MaskedEmail $maskedEmail;
+
+    public function __construct(
+        public readonly string $sourceIp,
+        public readonly string $activityType,
+        public readonly int $requestCount,
+        public readonly string $timeWindow,
+        public readonly ?string $email = null
+    ) {
+        $this->maskedEmail = $this->email ? MaskedEmail::fromString($this->email) : null;
+    }
+
+    public function getOWASPEventIdentifier(): OWASPEventIdentifier
+    {
+        return OWASPEventIdentifier::suspiciousNetworkActivity($this->activityType);
+    }
+
+    public function getOWASPLogLevel(): OWASPLogLevel
+    {
+        return OWASPLogLevel::WARN;
+    }
+
+    public function getDescription(): string
+    {
+        return "Suspicious network activity detected: {$this->activityType}";
+    }
+
+    public function getEventData(): array
+    {
+        return [
+            'source_ip' => $this->sourceIp,
+            'activity_type' => $this->activityType,
+            'request_count' => $this->requestCount,
+            'time_window' => $this->timeWindow,
+            'username' => $this->maskedEmail?->toString() ?? 'anonymous'
+        ];
+    }
+
+    public function getMaskedEmail(): ?MaskedEmail
+    {
+        return $this->maskedEmail;
+    }
+}
diff --git a/src/Application/Security/Events/Session/SessionFixationEvent.php b/src/Application/Security/Events/Session/SessionFixationEvent.php
new file mode 100644
index 00000000..bac39eaf
--- /dev/null
+++ b/src/Application/Security/Events/Session/SessionFixationEvent.php
@@ -0,0 +1,51 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Application\Security\Events\Session;
+
+use App\Application\Security\{OWASPSecurityEvent};
+use App\Application\Security\ValueObjects\{OWASPEventIdentifier, OWASPLogLevel, MaskedEmail};
+
+final class SessionFixationEvent implements OWASPSecurityEvent
+{
+    private ?MaskedEmail $maskedEmail;
+
+    public function __construct(
+        public readonly ?string $email,
+        public readonly string $oldSessionId,
+        public readonly string $newSessionId,
+        public readonly string $attackVector
+    ) {
+        $this->maskedEmail = $this->email ? MaskedEmail::fromString($this->email) : null;
+    }
+
+    public function getOWASPEventIdentifier(): OWASPEventIdentifier
+    {
+        return OWASPEventIdentifier::sessionFixation($this->maskedEmail?->toString() ?? 'anonymous');
+    }
+
+    public function getOWASPLogLevel(): OWASPLogLevel
+    {
+        return OWASPLogLevel::FATAL;
+    }
+
+    public function getDescription(): string
+    {
+        return "Session fixation attack detected for user {$this->maskedEmail?->toString() ?? 'anonymous'}";
+    }
+
+    public function getEventData(): array
+    {
+        return [
+            'username' => $this->maskedEmail?->toString() ?? 'anonymous',
+            'old_session_id' => hash('sha256', $this->oldSessionId),
+            'new_session_id' => hash('sha256', $this->newSessionId),
+            'attack_vector' => $this->attackVector
+        ];
+    }
+
+    public function getMaskedEmail(): ?MaskedEmail
+    {
+        return $this->maskedEmail;
+    }
+}
diff --git a/src/Application/Security/Events/Session/SessionHijackingDetectedEvent.php b/src/Application/Security/Events/Session/SessionHijackingDetectedEvent.php
new file mode 100644
index 00000000..dea095f0
--- /dev/null
+++ b/src/Application/Security/Events/Session/SessionHijackingDetectedEvent.php
@@ -0,0 +1,53 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Application\Security\Events\Session;
+
+use App\Application\Security\ValueObjects\{OWASPEventIdentifier, OWASPLogLevel};
+
+final class SessionHijackingDetectedEvent
+{
+    public function __construct(
+        public readonly string $email,
+        public readonly string $sessionId,
+        public readonly string $evidence,
+        public readonly ?string $suspiciousIp = null
+    ) {}
+
+    public function getOWASPEventIdentifier(): OWASPEventIdentifier
+    {
+        return OWASPEventIdentifier::sessionHijacking($this->maskEmail($this->email));
+    }
+
+    public function getOWASPLogLevel(): OWASPLogLevel
+    {
+        return OWASPLogLevel::FATAL;
+    }
+
+    public function getDescription(): string
+    {
+        return "Session hijacking detected for user {$this->maskEmail($this->email)}";
+    }
+
+    public function getEventData(): array
+    {
+        return [
+            'username' => $this->maskEmail($this->email),
+            'session_id' => hash('sha256', $this->sessionId),
+            'evidence' => $this->evidence,
+            'suspicious_ip' => $this->suspiciousIp
+        ];
+    }
+
+    private function maskEmail(string $email): string
+    {
+        if (!filter_var($email, FILTER_VALIDATE_EMAIL)) {
+            return $email;
+        }
+
+        [$local, $domain] = explode('@', $email, 2);
+        $maskedLocal = substr($local, 0, 2) . str_repeat('*', max(0, strlen($local) - 2));
+
+        return $maskedLocal . '@' . $domain;
+    }
+}
diff --git a/src/Application/Security/Events/Session/SessionTimeoutEvent.php b/src/Application/Security/Events/Session/SessionTimeoutEvent.php
new file mode 100644
index 00000000..562d0238
--- /dev/null
+++ b/src/Application/Security/Events/Session/SessionTimeoutEvent.php
@@ -0,0 +1,51 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Application\Security\Events\Session;
+
+use App\Application\Security\{OWASPSecurityEvent};
+use App\Application\Security\ValueObjects\{OWASPEventIdentifier, OWASPLogLevel, MaskedEmail};
+
+final class SessionTimeoutEvent implements OWASPSecurityEvent
+{
+    private ?MaskedEmail $maskedEmail;
+
+    public function __construct(
+        public readonly ?string $email,
+        public readonly string $sessionId,
+        public readonly int $inactivityDuration,
+        public readonly string $reason = 'timeout'
+    ) {
+        $this->maskedEmail = $this->email ? MaskedEmail::fromString($this->email) : null;
+    }
+
+    public function getOWASPEventIdentifier(): OWASPEventIdentifier
+    {
+        return OWASPEventIdentifier::sessionTimeout($this->maskedEmail?->toString() ?? 'anonymous');
+    }
+
+    public function getOWASPLogLevel(): OWASPLogLevel
+    {
+        return OWASPLogLevel::WARN;
+    }
+
+    public function getDescription(): string
+    {
+        return "Session timeout for user {$this->maskedEmail?->toString() ?? 'anonymous'}";
+    }
+
+    public function getEventData(): array
+    {
+        return [
+            'username' => $this->maskedEmail?->toString() ?? 'anonymous',
+            'session_id' => hash('sha256', $this->sessionId),
+            'inactivity_duration' => $this->inactivityDuration,
+            'timeout_reason' => $this->reason
+        ];
+    }
+
+    public function getMaskedEmail(): ?MaskedEmail
+    {
+        return $this->maskedEmail;
+    }
+}
diff --git a/src/Application/Security/Events/System/SystemAnomalyEvent.php b/src/Application/Security/Events/System/SystemAnomalyEvent.php
new file mode 100644
index 00000000..cecaeeeb
--- /dev/null
+++ b/src/Application/Security/Events/System/SystemAnomalyEvent.php
@@ -0,0 +1,48 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Application\Security\Events\System;
+
+use App\Application\Security\{OWASPSecurityEvent};
+use App\Application\Security\ValueObjects\{OWASPEventIdentifier, OWASPLogLevel, MaskedEmail};
+
+final class SystemAnomalyEvent implements OWASPSecurityEvent
+{
+    public function __construct(
+        public readonly string $anomalyType,
+        public readonly string $description,
+        public readonly array $metrics,
+        public readonly string $severity
+    ) {}
+
+    public function getOWASPEventIdentifier(): OWASPEventIdentifier
+    {
+        return OWASPEventIdentifier::systemAnomaly($this->anomalyType);
+    }
+
+    public function getOWASPLogLevel(): OWASPLogLevel
+    {
+        return match ($this->severity) {
+            'low' => OWASPLogLevel::INFO,
+            'medium' => OWASPLogLevel::WARN,
+            'high' => OWASPLogLevel::ERROR,
+            'critical' => OWASPLogLevel::FATAL,
+            default => OWASPLogLevel::WARN
+        };
+    }
+
+    public function getDescription(): string
+    {
+        return "System anomaly detected: {$this->anomalyType}";
+    }
+
+    public function getEventData(): array
+    {
+        return [
+            'anomaly_type' => $this->anomalyType,
+            'description' => $this->description,
+            'metrics' => $this->metrics,
+            'severity' => $this->severity
+        ];
+    }
+}
diff --git a/src/Application/Security/Events/Web/CsrfViolationEvent.php b/src/Application/Security/Events/Web/CsrfViolationEvent.php
new file mode 100644
index 00000000..37a49ff5
--- /dev/null
+++ b/src/Application/Security/Events/Web/CsrfViolationEvent.php
@@ -0,0 +1,53 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Application\Security\Events\Web;
+
+use App\Application\Security\{OWASPSecurityEvent};
+use App\Application\Security\ValueObjects\{OWASPEventIdentifier, OWASPLogLevel, MaskedEmail};
+
+final class CsrfViolationEvent implements OWASPSecurityEvent
+{
+    private ?MaskedEmail $maskedEmail;
+
+    public function __construct(
+        public readonly string $requestPath,
+        public readonly string $method,
+        public readonly ?string $expectedToken = null,
+        public readonly ?string $providedToken = null,
+        public readonly ?string $email = null
+    ) {
+        $this->maskedEmail = $this->email ? MaskedEmail::fromString($this->email) : null;
+    }
+
+    public function getOWASPEventIdentifier(): OWASPEventIdentifier
+    {
+        return OWASPEventIdentifier::csrfViolation($this->requestPath);
+    }
+
+    public function getOWASPLogLevel(): OWASPLogLevel
+    {
+        return OWASPLogLevel::ERROR;
+    }
+
+    public function getDescription(): string
+    {
+        return "CSRF token validation failed for {$this->method} {$this->requestPath}";
+    }
+
+    public function getEventData(): array
+    {
+        return [
+            'request_path' => $this->requestPath,
+            'method' => $this->method,
+            'expected_token_hash' => $this->expectedToken ? hash('sha256', $this->expectedToken) : null,
+            'provided_token_hash' => $this->providedToken ? hash('sha256', $this->providedToken) : null,
+            'username' => $this->maskedEmail?->toString() ?? 'anonymous'
+        ];
+    }
+
+    public function getMaskedEmail(): ?MaskedEmail
+    {
+        return $this->maskedEmail;
+    }
+}
diff --git a/src/Application/Security/ExceptionHandlers/SecurityExceptionHandler.php b/src/Application/Security/ExceptionHandlers/SecurityExceptionHandler.php
new file mode 100644
index 00000000..b0e3c68e
--- /dev/null
+++ b/src/Application/Security/ExceptionHandlers/SecurityExceptionHandler.php
@@ -0,0 +1,142 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Application\Security\ExceptionHandlers;
+
+use App\Application\Security\Events\{
+    Authorization\AccessDeniedEvent,
+    Input\InputValidationFailureEvent,
+    System\SystemAnomalyEvent,
+    Crypto\CryptographicFailureEvent
+};
+use App\Framework\Core\Events\EventDispatcher;
+use App\Framework\Core\Exceptions\{
+    ValidationException,
+    CryptographicException
+};
+use Psr\Log\LoggerInterface;
+use Symfony\Component\Finder\Exception\AccessDeniedException;
+use Throwable;
+
+final class SecurityExceptionHandler
+{
+    public function __construct(
+        private EventDispatcher $eventDispatcher,
+        private LoggerInterface $logger
+    ) {}
+
+    public function handle(Throwable $exception): void
+    {
+        match (true) {
+            $exception instanceof AccessDeniedException => $this->handleAccessDenied($exception),
+            $exception instanceof ValidationException => $this->handleValidationError($exception),
+            $exception instanceof CryptographicException => $this->handleCryptographicError($exception),
+            $exception instanceof \Error => $this->handleSystemError($exception),
+            default => $this->handleGenericSecurityIssue($exception)
+        };
+    }
+
+    private function handleAccessDenied(AccessDeniedException $exception): void
+    {
+        $this->eventDispatcher->dispatch(new AccessDeniedEvent(
+            email: $this->getCurrentUserEmail(),
+            resource: $exception->getResource(),
+            action: $exception->getAction(),
+            requiredPermission: $exception->getRequiredPermission()
+        ));
+    }
+
+    private function handleValidationError(ValidationException $exception): void
+    {
+        foreach ($exception->getErrors() as $field => $errors) {
+            $this->eventDispatcher->dispatch(new InputValidationFailureEvent(
+                fieldName: $field,
+                invalidValue: $exception->getInvalidValue($field) ?? '',
+                validationRule: implode(', ', $errors),
+                email: $this->getCurrentUserEmail()
+            ));
+        }
+    }
+
+    private function handleCryptographicError(CryptographicException $exception): void
+    {
+        $this->eventDispatcher->dispatch(new CryptographicFailureEvent(
+            operation: $exception->getOperation(),
+            algorithm: $exception->getAlgorithm(),
+            errorMessage: $exception->getMessage(),
+            email: $this->getCurrentUserEmail()
+        ));
+    }
+
+    private function handleSystemError(\Error $exception): void
+    {
+        $this->eventDispatcher->dispatch(new SystemAnomalyEvent(
+            anomalyType: 'system_error',
+            description: $exception->getMessage(),
+            metrics: [
+                'error_type' => get_class($exception),
+                'file' => $exception->getFile(),
+                'line' => $exception->getLine(),
+                'memory_usage' => memory_get_usage(true)
+            ],
+            severity: 'high'
+        ));
+    }
+
+    private function handleGenericSecurityIssue(Throwable $exception): void
+    {
+        // Nur bei tatsächlich sicherheitsrelevanten Exceptions loggen
+        if ($this->isSecurityRelevant($exception)) {
+            $this->logger->warning('Security-relevant exception detected', [
+                'exception_class' => get_class($exception),
+                'message' => $exception->getMessage(),
+                'user_email' => $this->getCurrentUserEmail(),
+                'security_context' => [
+                    'ip' => $_SERVER['REMOTE_ADDR'] ?? 'unknown',
+                    'user_agent' => $_SERVER['HTTP_USER_AGENT'] ?? null,
+                    'request_uri' => $_SERVER['REQUEST_URI'] ?? null
+                ]
+            ]);
+        }
+    }
+
+    private function isSecurityRelevant(Throwable $exception): bool
+    {
+        $securityRelevantClasses = [
+            'AccessDeniedException',
+            'AuthenticationException',
+            'AuthorizationException',
+            'ValidationException',
+            'CryptographicException',
+            'FileUploadException',
+            'SessionException'
+        ];
+
+        $className = get_class($exception);
+        foreach ($securityRelevantClasses as $securityClass) {
+            if (str_contains($className, $securityClass)) {
+                return true;
+            }
+        }
+
+        // Sicherheitsrelevante Nachrichten prüfen
+        $message = strtolower($exception->getMessage());
+        $securityKeywords = [
+            'access denied', 'unauthorized', 'permission', 'authentication',
+            'authorization', 'csrf', 'xss', 'injection', 'validation failed'
+        ];
+
+        foreach ($securityKeywords as $keyword) {
+            if (str_contains($message, $keyword)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    private function getCurrentUserEmail(): ?string
+    {
+        return $_SESSION['user_email'] ?? null;
+    }
+}
diff --git a/src/Application/Security/Guards/AuthenticationGuard.php b/src/Application/Security/Guards/AuthenticationGuard.php
new file mode 100644
index 00000000..b58c8a72
--- /dev/null
+++ b/src/Application/Security/Guards/AuthenticationGuard.php
@@ -0,0 +1,129 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Application\Security\Guards;
+
+use App\Framework\Database\Example\UserRepository;
+use App\Application\Security\Events\Auth\{
+    AuthenticationSuccessEvent,
+    AuthenticationFailedEvent,
+    AccountLockedEvent
+};
+use App\Framework\Core\Events\EventDispatcher;
+use App\Domain\User\{User};
+
+final class AuthenticationGuard
+{
+    private const MAX_FAILED_ATTEMPTS = 5;
+    private const LOCKOUT_DURATION = 900; // 15 Minuten
+
+    public function __construct(
+        private EventDispatcher $eventDispatcher,
+        private UserRepository $userRepository
+    ) {}
+
+    public function authenticate(string $email, string $password): ?User
+    {
+        try {
+            $user = $this->userRepository->findByEmail($email);
+
+            if (!$user) {
+                $this->dispatchFailedAttempt($email, 'user_not_found');
+                return null;
+            }
+
+            if ($this->isAccountLocked($user)) {
+                $this->dispatchAccountLocked($email, 'too_many_failed_attempts', $user->failed_attempts);
+                return null;
+            }
+
+            if (!$this->verifyPassword($password, $user->password_hash)) {
+                $this->handleFailedAttempt($user);
+                return null;
+            }
+
+            $this->handleSuccessfulLogin($user);
+            return $user;
+
+        } catch (\Exception $e) {
+            $this->dispatchFailedAttempt($email, 'authentication_error');
+            throw $e;
+        }
+    }
+
+    public function logout(User $user): void
+    {
+        $sessionId = session_id();
+
+        // Session invalidieren
+        session_destroy();
+
+        $this->eventDispatcher->dispatch(new \App\Application\Security\Events\Auth\SessionTerminatedEvent(
+            email: $user->email,
+            sessionId: $sessionId,
+            reason: 'manual_logout'
+        ));
+    }
+
+    private function handleSuccessfulLogin(User $user): void
+    {
+        // Failed attempts zurücksetzen
+        $user->failed_attempts = 0;
+        $user->last_login = new \DateTimeImmutable();
+        $this->userRepository->save($user);
+
+        // Session regenerieren
+        session_regenerate_id(true);
+        $_SESSION['user_id'] = $user->id;
+
+        $this->eventDispatcher->dispatch(new AuthenticationSuccessEvent(
+            email: $user->email,
+            sessionId: session_id(),
+            method: 'password'
+        ));
+    }
+
+    private function handleFailedAttempt(User $user): void
+    {
+        $user->failed_attempts++;
+        $user->last_failed_attempt = new \DateTimeImmutable();
+
+        if ($user->failed_attempts >= self::MAX_FAILED_ATTEMPTS) {
+            $user->locked_until = new \DateTimeImmutable('+' . self::LOCKOUT_DURATION . ' seconds');
+            $this->userRepository->save($user);
+
+            $this->dispatchAccountLocked($user->email, 'max_attempts_exceeded', $user->failed_attempts);
+        } else {
+            $this->userRepository->save($user);
+            $this->dispatchFailedAttempt($user->email, 'invalid_password', $user->failed_attempts);
+        }
+    }
+
+    private function dispatchFailedAttempt(string $email, string $reason, int $attempts = 1): void
+    {
+        $this->eventDispatcher->dispatch(new AuthenticationFailedEvent(
+            email: $email,
+            reason: $reason,
+            failedAttempts: $attempts
+        ));
+    }
+
+    private function dispatchAccountLocked(string $email, string $reason, int $attempts): void
+    {
+        $this->eventDispatcher->dispatch(new AccountLockedEvent(
+            email: $email,
+            reason: $reason,
+            failedAttempts: $attempts
+        ));
+    }
+
+    private function isAccountLocked(User $user): bool
+    {
+        return $user->locked_until && $user->locked_until > new \DateTimeImmutable();
+    }
+
+    private function verifyPassword(string $password, string $hash): bool
+    {
+        return password_verify($password, $hash);
+    }
+}
diff --git a/src/Application/Security/Middleware/SecurityEventMiddleware.php b/src/Application/Security/Middleware/SecurityEventMiddleware.php
new file mode 100644
index 00000000..e913a2f9
--- /dev/null
+++ b/src/Application/Security/Middleware/SecurityEventMiddleware.php
@@ -0,0 +1,106 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Application\Security\Middleware;
+
+use App\Application\Security\Events\{
+    Web\CsrfViolationEvent,
+    Network\SuspiciousNetworkActivityEvent,
+    Input\InputValidationFailureEvent
+};
+use App\Framework\Core\Events\EventDispatcher;
+use Psr\Http\Message\{ServerRequestInterface, ResponseInterface};
+use Psr\Http\Server\{MiddlewareInterface, RequestHandlerInterface};
+
+final class SecurityEventMiddleware implements MiddlewareInterface
+{
+    private array $requestCounts = [];
+    private const RATE_LIMIT_THRESHOLD = 100;
+    private const TIME_WINDOW = 300; // 5 Minuten
+
+    public function __construct(
+        private EventDispatcher $eventDispatcher
+    ) {}
+
+    public function process(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface
+    {
+        $this->checkRateLimit($request);
+        $this->validateCsrfToken($request);
+
+        $response = $handler->handle($request);
+
+        $this->analyzeResponse($request, $response);
+
+        return $response;
+    }
+
+    private function checkRateLimit(ServerRequestInterface $request): void
+    {
+        $clientIp = $this->getClientIp($request);
+        $currentTime = time();
+
+        // Rate Limiting Check
+        if (!isset($this->requestCounts[$clientIp])) {
+            $this->requestCounts[$clientIp] = [];
+        }
+
+        // Alte Einträge entfernen
+        $this->requestCounts[$clientIp] = array_filter(
+            $this->requestCounts[$clientIp],
+            fn($timestamp) => $currentTime - $timestamp < self::TIME_WINDOW
+        );
+
+        $this->requestCounts[$clientIp][] = $currentTime;
+
+        if (count($this->requestCounts[$clientIp]) > self::RATE_LIMIT_THRESHOLD) {
+            $this->eventDispatcher->dispatch(new SuspiciousNetworkActivityEvent(
+                sourceIp: $clientIp,
+                activityType: 'rate_limit_exceeded',
+                requestCount: count($this->requestCounts[$clientIp]),
+                timeWindow: self::TIME_WINDOW . 's'
+            ));
+        }
+    }
+
+    private function validateCsrfToken(ServerRequestInterface $request): void
+    {
+        $method = $request->getMethod();
+        if (!in_array($method, ['POST', 'PUT', 'DELETE', 'PATCH'])) {
+            return;
+        }
+
+        $sessionToken = $_SESSION['csrf_token'] ?? null;
+        $requestToken = $request->getParsedBody()['csrf_token'] ??
+                       $request->getHeaderLine('X-CSRF-Token');
+
+        if (!$sessionToken || !$requestToken || !hash_equals($sessionToken, $requestToken)) {
+            $this->eventDispatcher->dispatch(new CsrfViolationEvent(
+                requestPath: $request->getUri()->getPath(),
+                method: $method,
+                expectedToken: $sessionToken,
+                providedToken: $requestToken
+            ));
+        }
+    }
+
+    private function analyzeResponse(ServerRequestInterface $request, ResponseInterface $response): void
+    {
+        // Suspicious response patterns
+        if ($response->getStatusCode() === 403) {
+            // Access denied - könnte bereits von Authorization Middleware gehandhabt werden
+        }
+
+        if ($response->getStatusCode() >= 500) {
+            // Server errors - könnte auf Angriffe hindeuten
+        }
+    }
+
+    private function getClientIp(ServerRequestInterface $request): string
+    {
+        $serverParams = $request->getServerParams();
+        return $serverParams['HTTP_X_FORWARDED_FOR'] ??
+               $serverParams['HTTP_X_REAL_IP'] ??
+               $serverParams['REMOTE_ADDR'] ??
+               'unknown';
+    }
+}
diff --git a/src/Application/Security/OWASPSecurityEvent.php b/src/Application/Security/OWASPSecurityEvent.php
new file mode 100644
index 00000000..baf0ca50
--- /dev/null
+++ b/src/Application/Security/OWASPSecurityEvent.php
@@ -0,0 +1,29 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Application\Security;
+
+use App\Application\Security\ValueObjects\{OWASPEventIdentifier, OWASPLogLevel};
+
+interface OWASPSecurityEvent
+{
+    /**
+     * Gibt den OWASP-konformen Event-Identifier zurück
+     */
+    public function getOWASPEventIdentifier(): OWASPEventIdentifier;
+
+    /**
+     * Gibt das entsprechende Log-Level zurück
+     */
+    public function getOWASPLogLevel(): OWASPLogLevel;
+
+    /**
+     * Gibt eine menschenlesbare Beschreibung des Events zurück
+     */
+    public function getDescription(): string;
+
+    /**
+     * Gibt strukturierte Event-Daten für das Logging zurück
+     */
+    public function getEventData(): array;
+}
diff --git a/src/Application/Security/OWASPSecurityEventFactory.php b/src/Application/Security/OWASPSecurityEventFactory.php
new file mode 100644
index 00000000..21112963
--- /dev/null
+++ b/src/Application/Security/OWASPSecurityEventFactory.php
@@ -0,0 +1,210 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Application\Security;
+
+use App\Application\Security\ValueObjects\{
+    SecurityContext,
+    RequestContext,
+    OWASPLogFormat,
+    OWASPEventIdentifier,
+    OWASPLogLevel
+};
+
+final class OWASPSecurityEventFactory
+{
+    public function __construct(
+        private string $applicationId = 'app.security'
+    ) {}
+
+    public function createFromSecurityEvent(
+        SecurityEvent $event,
+        SecurityContext $context,
+        RequestContext $requestContext
+    ): OWASPLogFormat {
+        $eventIdentifier = $this->createEventIdentifier($event);
+        $logLevel = OWASPLogLevel::fromSecurityEventType($event->type);
+        $description = $this->createDescription($event, $eventIdentifier);
+
+        return OWASPLogFormat::create(
+            $this->applicationId,
+            $eventIdentifier->toString(),
+            $logLevel->value,
+            $description,
+            $context,
+            $requestContext
+        );
+    }
+
+    private function createEventIdentifier(SecurityEvent $event): OWASPEventIdentifier
+    {
+        return match ($event->type) {
+            SecurityEventType::LOGIN_FAILED => $this->createLoginFailedIdentifier($event),
+            SecurityEventType::LOGIN_SUCCESS => $this->createLoginSuccessIdentifier($event),
+            SecurityEventType::LOGOUT => $this->createLogoutIdentifier($event),
+            SecurityEventType::PASSWORD_CHANGE => $this->createPasswordChangeIdentifier($event),
+            SecurityEventType::ACCOUNT_LOCKED => $this->createAccountLockedIdentifier($event),
+            SecurityEventType::ACCESS_DENIED => $this->createAccessDeniedIdentifier($event),
+            SecurityEventType::PRIVILEGE_ESCALATION => $this->createPrivilegeEscalationIdentifier($event),
+            SecurityEventType::DATA_ACCESS => $this->createDataAccessIdentifier($event),
+            SecurityEventType::INJECTION_ATTEMPT => $this->createInjectionAttemptIdentifier($event),
+            SecurityEventType::FILE_UPLOAD => $this->createFileUploadIdentifier($event),
+            SecurityEventType::SESSION_HIJACK => $this->createSessionHijackIdentifier($event),
+            SecurityEventType::SESSION_TIMEOUT => $this->createSessionTimeoutIdentifier($event),
+            SecurityEventType::MALWARE_DETECTED => $this->createMalwareDetectedIdentifier($event),
+            SecurityEventType::AUDIT_FAILURE => $this->createAuditFailureIdentifier($event),
+        };
+    }
+
+    private function createLoginFailedIdentifier(SecurityEvent $event): OWASPEventIdentifier
+    {
+        $username = $this->extractUsername($event);
+        return OWASPEventIdentifier::authenticationFailure($username);
+    }
+
+    private function createLoginSuccessIdentifier(SecurityEvent $event): OWASPEventIdentifier
+    {
+        $username = $this->extractUsername($event);
+        return OWASPEventIdentifier::authenticationSuccess($username);
+    }
+
+    private function createLogoutIdentifier(SecurityEvent $event): OWASPEventIdentifier
+    {
+        $username = $this->extractUsername($event);
+        return OWASPEventIdentifier::sessionTermination($username);
+    }
+
+    private function createPasswordChangeIdentifier(SecurityEvent $event): OWASPEventIdentifier
+    {
+        $username = $this->extractUsername($event);
+        return OWASPEventIdentifier::passwordChange($username);
+    }
+
+    private function createAccountLockedIdentifier(SecurityEvent $event): OWASPEventIdentifier
+    {
+        $username = $this->extractUsername($event);
+        return OWASPEventIdentifier::accountLocked($username);
+    }
+
+    private function createAccessDeniedIdentifier(SecurityEvent $event): OWASPEventIdentifier
+    {
+        $username = $this->extractUsername($event);
+        $resource = $this->extractProperty($event, 'resource', 'unknown_resource');
+        return OWASPEventIdentifier::authorizationFailure($username, $resource);
+    }
+
+    private function createPrivilegeEscalationIdentifier(SecurityEvent $event): OWASPEventIdentifier
+    {
+        $username = $this->extractUsername($event);
+        $fromRole = $this->extractProperty($event, 'fromRole', 'user');
+        $toRole = $this->extractProperty($event, 'toRole', 'admin');
+        return OWASPEventIdentifier::privilegeEscalation($username, $fromRole, $toRole);
+    }
+
+    private function createDataAccessIdentifier(SecurityEvent $event): OWASPEventIdentifier
+    {
+        $field = $this->extractProperty($event, 'field', 'unknown');
+        return OWASPEventIdentifier::inputValidationFailure($field);
+    }
+
+    private function createInjectionAttemptIdentifier(SecurityEvent $event): OWASPEventIdentifier
+    {
+        $attackType = $this->extractProperty($event, 'attackType', 'injection');
+        return OWASPEventIdentifier::maliciousInput($attackType);
+    }
+
+    private function createFileUploadIdentifier(SecurityEvent $event): OWASPEventIdentifier
+    {
+        $filename = $this->extractProperty($event, 'filename', 'unknown.file');
+        return OWASPEventIdentifier::fileUploadFailure($filename);
+    }
+
+    private function createSessionHijackIdentifier(SecurityEvent $event): OWASPEventIdentifier
+    {
+        $username = $this->extractUsername($event);
+        return OWASPEventIdentifier::sessionHijacking($username);
+    }
+
+    private function createSessionTimeoutIdentifier(SecurityEvent $event): OWASPEventIdentifier
+    {
+        $username = $this->extractUsername($event);
+        return OWASPEventIdentifier::sessionTimeout($username);
+    }
+
+    private function createMalwareDetectedIdentifier(SecurityEvent $event): OWASPEventIdentifier
+    {
+        $malwareType = $this->extractProperty($event, 'malwareType', 'unknown');
+        return OWASPEventIdentifier::malwareDetected($malwareType);
+    }
+
+    private function createAuditFailureIdentifier(SecurityEvent $event): OWASPEventIdentifier
+    {
+        $eventType = $this->extractProperty($event, 'eventType', $event->type->value);
+        return OWASPEventIdentifier::auditFailure($eventType);
+    }
+
+    private function createDescription(SecurityEvent $event, OWASPEventIdentifier $identifier): string
+    {
+        return match ($event->type) {
+            SecurityEventType::LOGIN_FAILED => "User {$this->extractUsername($event)} login failed",
+            SecurityEventType::LOGIN_SUCCESS => "User {$this->extractUsername($event)} login successfully",
+            SecurityEventType::LOGOUT => "User {$this->extractUsername($event)} logged out",
+            SecurityEventType::PASSWORD_CHANGE => "User {$this->extractUsername($event)} changed password",
+            SecurityEventType::ACCOUNT_LOCKED => "Account {$this->extractUsername($event)} locked",
+            SecurityEventType::ACCESS_DENIED => "Access denied for user {$this->extractUsername($event)} to resource {$this->extractProperty($event, 'resource', 'unknown_resource')}",
+            SecurityEventType::PRIVILEGE_ESCALATION => "Privilege escalation attempt by user {$this->extractUsername($event)}",
+            SecurityEventType::DATA_ACCESS => "Input validation failure for field {$this->extractProperty($event, 'field', 'unknown')}",
+            SecurityEventType::INJECTION_ATTEMPT => "Malicious input detected: {$this->extractProperty($event, 'attackType', 'injection')}",
+            SecurityEventType::FILE_UPLOAD => "File upload failed: {$this->extractProperty($event, 'filename', 'unknown.file')}",
+            SecurityEventType::SESSION_HIJACK => "Session hijacking detected for user {$this->extractUsername($event)}",
+            SecurityEventType::SESSION_TIMEOUT => "Session timeout for user {$this->extractUsername($event)}",
+            SecurityEventType::MALWARE_DETECTED => "Malware detected: {$this->extractProperty($event, 'malwareType', 'unknown')}",
+            SecurityEventType::AUDIT_FAILURE => "Audit logging failure for event {$event->type->value}",
+        };
+    }
+
+    private function extractUsername(SecurityEvent $event): string
+    {
+        $usernameFields = ['username', 'email', 'user', 'userId'];
+
+        foreach ($usernameFields as $field) {
+            $value = $this->extractProperty($event, $field);
+            if ($value !== null) {
+                return $this->maskEmail($value);
+            }
+        }
+
+        return 'anonymous';
+    }
+
+    private function extractProperty(SecurityEvent $event, string $propertyName, ?string $default = null): ?string
+    {
+        try {
+            $reflection = new \ReflectionObject($event);
+
+            if ($reflection->hasProperty($propertyName)) {
+                $property = $reflection->getProperty($propertyName);
+                $property->setAccessible(true);
+                $value = $property->getValue($event);
+
+                return is_string($value) ? $value : (string)$value;
+            }
+        } catch (\Exception) {
+            // Property nicht gefunden oder nicht lesbar
+        }
+
+        return $default;
+    }
+
+    private function maskEmail(string $value): string
+    {
+        if (!filter_var($value, FILTER_VALIDATE_EMAIL)) {
+            return $value;
+        }
+
+        [$local, $domain] = explode('@', $value, 2);
+        $maskedLocal = substr($local, 0, 2) . str_repeat('*', max(0, strlen($local) - 2));
+
+        return $maskedLocal . '@' . $domain;
+    }
+}
diff --git a/src/Application/Security/OWASPSecurityEventLogger.php b/src/Application/Security/OWASPSecurityEventLogger.php
new file mode 100644
index 00000000..1003199d
--- /dev/null
+++ b/src/Application/Security/OWASPSecurityEventLogger.php
@@ -0,0 +1,89 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Application\Security;
+
+use App\Application\Security\ValueObjects\{
+    SecurityContext,
+    RequestContext,
+    OWASPLogFormat,
+    OWASPLogLevel
+};
+use App\Framework\Core\Events\OnEvent;
+use Psr\Log\LoggerInterface;
+use Throwable;
+
+final class OWASPSecurityEventLogger
+{
+    public function __construct(
+        private LoggerInterface $logger,
+        private string $applicationId = 'app.security'
+    ) {}
+
+    /**
+     * Universeller Event-Handler für alle OWASP Security Events
+     */
+    #[OnEvent]
+    public function logSecurityEvent(OWASPSecurityEvent $event): void
+    {
+        try {
+            $securityContext = SecurityContext::fromGlobals();
+            $requestContext = RequestContext::fromGlobals();
+
+            $owaspLogFormat = $this->createOWASPLogFormat(
+                $event,
+                $securityContext,
+                $requestContext
+            );
+
+            // OWASP-konformes JSON-Log
+            $this->logger->log(
+                $this->mapLogLevel($event->getOWASPLogLevel()),
+                $event->getDescription(),
+                [
+                    'owasp_format' => $owaspLogFormat->toArray(),
+                    'event_class' => $event::class,
+                    'event_data' => $event->getEventData()
+                ]
+            );
+
+        } catch (Throwable $e) {
+            // Fallback logging - niemals Security-Events verlieren
+            $this->logger->critical('AUDIT_audit_failure:owasp_logger', [
+                'datetime' => date('c'),
+                'appid' => $this->applicationId,
+                'event' => 'AUDIT_audit_failure:owasp_logger',
+                'level' => 'FATAL',
+                'description' => 'OWASP security event logging failed: ' . $e->getMessage(),
+                'original_event_class' => $event::class,
+                'error_trace' => $e->getTraceAsString()
+            ]);
+        }
+    }
+
+    private function createOWASPLogFormat(
+        OWASPSecurityEvent $event,
+        SecurityContext $securityContext,
+        RequestContext $requestContext
+    ): OWASPLogFormat {
+        return OWASPLogFormat::create(
+            $this->applicationId,
+            $event->getOWASPEventIdentifier()->toString(),
+            $event->getOWASPLogLevel()->value,
+            $event->getDescription(),
+            $securityContext,
+            $requestContext
+        );
+    }
+
+    private function mapLogLevel(OWASPLogLevel $owaspLevel): string
+    {
+        return match ($owaspLevel) {
+            OWASPLogLevel::DEBUG => 'debug',
+            OWASPLogLevel::INFO => 'info',
+            OWASPLogLevel::WARN => 'warning',
+            OWASPLogLevel::ERROR => 'error',
+            OWASPLogLevel::FATAL => 'critical'
+        };
+    }
+}
diff --git a/src/Application/Security/SecurityContext.php b/src/Application/Security/SecurityContext.php
new file mode 100644
index 00000000..09b9a130
--- /dev/null
+++ b/src/Application/Security/SecurityContext.php
@@ -0,0 +1,53 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Application\Security;
+
+/**
+ * Beispiel für Logeintrag:
+ * {
+ * 'timestamp': '2025-06-01T00:52:10Z',
+ * 'event': 'auth.login.failed',
+ * 'ip': '203.0.113.42',
+ * 'user_agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7)',
+ * 'request_uri': '/login',
+ * 'method': 'POST',
+ * 'user_id': null,
+ * 'email': 'j***@example.com',
+ * 'session_id': 'abc123',
+ * 'referrer': 'https://example.com/login',
+ * 'result': 'fail',
+ * 'request_id': 'req-3d92fcb45e'
+ * }
+ *
+ */
+
+final readonly class SecurityContext
+{
+    public function __construct(
+        public string             $ip,
+        public ?string            $userAgent,
+        public string             $method,
+        public string             $uri,
+        public \DateTimeImmutable $timestamp,
+        public ?string            $userId = null,
+        public ?string            $sessionId = null,
+        public ?string            $referrer = null,
+        public ?string            $requestId = null
+    ) {}
+
+    public static function fromGlobals(): self
+    {
+        return new self(
+            ip: $_SERVER['REMOTE_ADDR'] ?? 'unknown',
+            userAgent: $_SERVER['HTTP_USER_AGENT'] ?? null,
+            method: $_SERVER['REQUEST_METHOD'] ?? 'CLI',
+            uri: $_SERVER['REQUEST_URI'] ?? '-',
+            timestamp: new \DateTimeImmutable(),
+            userId: $_SESSION['user_id'] ?? null,
+            sessionId: session_id() ?: null,
+            referrer: $_SERVER['HTTP_REFERER'] ?? null,
+            requestId: $_SERVER['HTTP_X_REQUEST_ID'] ?? bin2hex(random_bytes(8))
+        );
+    }
+}
diff --git a/src/Application/Security/SecurityEvent.php b/src/Application/Security/SecurityEvent.php
new file mode 100644
index 00000000..ac44ab11
--- /dev/null
+++ b/src/Application/Security/SecurityEvent.php
@@ -0,0 +1,10 @@
+<?php
+
+namespace App\Application\Security;
+
+interface SecurityEvent
+{
+    public SecurityEventType $type {
+        get;
+    }
+}
diff --git a/src/Application/Security/SecurityEventLogger.php b/src/Application/Security/SecurityEventLogger.php
new file mode 100644
index 00000000..5dc2e046
--- /dev/null
+++ b/src/Application/Security/SecurityEventLogger.php
@@ -0,0 +1,84 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Application\Security;
+
+use App\Application\Security\ValueObjects\{SecurityContext as SecurityContextVO, RequestContext};
+use App\Framework\Core\Events\OnEvent;
+use Psr\Log\LoggerInterface;
+use Throwable;
+
+final class SecurityEventLogger
+{
+    public function __construct(
+        private LoggerInterface $logger,
+        private ?OWASPSecurityEventFactory $eventFactory = null
+    ) {
+        $this->eventFactory ??= new OWASPSecurityEventFactory();
+    }
+
+    #[OnEvent]
+    public function log(SecurityEvent $event): void
+    {
+        try {
+            // OWASP-konforme Logging
+            $this->logOWASPFormat($event);
+
+            // Fallback: Ursprüngliches Format beibehalten
+            $this->logLegacyFormat($event);
+
+        } catch (Throwable $e) {
+            // Fallback logging - niemals Security-Events verlieren
+            $this->logger->critical('AUDIT_audit_failure:security_logger', [
+                'datetime' => date('c'),
+                'appid' => 'app.security',
+                'event' => 'AUDIT_audit_failure:security_logger',
+                'level' => 'FATAL',
+                'description' => 'Security event logging failed: ' . $e->getMessage(),
+                'original_event_type' => $event->type->value ?? 'UNKNOWN',
+                'error_trace' => $e->getTraceAsString()
+            ]);
+        }
+    }
+
+    private function logOWASPFormat(SecurityEvent $event): void
+    {
+        $securityContext = SecurityContextVO::fromGlobals();
+        $requestContext = RequestContext::fromGlobals();
+
+        $owaspLogFormat = $this->eventFactory->createFromSecurityEvent(
+            $event,
+            $securityContext,
+            $requestContext
+        );
+
+        // Als strukturiertes JSON loggen
+        $this->logger->info($owaspLogFormat->getDescription(), [
+            'owasp_format' => $owaspLogFormat->toArray()
+        ]);
+    }
+
+    private function logLegacyFormat(SecurityEvent $event): void
+    {
+        $context = SecurityContext::fromGlobals();
+        $payload = $this->extractPayload($event);
+
+        $this->logger->warning($event->type->value, [
+            ...$payload,
+            'ip' => $context->ip,
+            'user_agent' => $context->userAgent,
+            'timestamp' => $context->timestamp->format('c'),
+        ]);
+    }
+
+    private function extractPayload(SecurityEvent $event): array
+    {
+        $data = [];
+        $ref = new \ReflectionObject($event);
+        foreach ($ref->getProperties() as $prop) {
+            $prop->setAccessible(true);
+            $data[$prop->getName()] = $prop->getValue($event);
+        }
+        return $data;
+    }
+}
diff --git a/src/Application/Security/SecurityEventType.php b/src/Application/Security/SecurityEventType.php
new file mode 100644
index 00000000..bc37b89d
--- /dev/null
+++ b/src/Application/Security/SecurityEventType.php
@@ -0,0 +1,20 @@
+<?php
+
+namespace App\Application\Security;
+
+enum SecurityEventType: string
+{
+    case LOGIN_FAILED        = 'auth.login.failed';
+    case LOGIN_SUCCEEDED     = 'auth.login.succeeded';
+    case LOGOUT              = 'auth.logout';
+
+    case PASSWORD_CHANGED    = 'account.password.changed';
+    case EMAIL_CHANGED       = 'account.email.changed';
+    case USER_DELETED        = 'account.deleted';
+
+    case ACCESS_DENIED       = 'access.denied';
+    case CSRF_VIOLATION      = 'access.csrf.violation';
+
+    case ADMIN_ACTION        = 'system.admin.action';
+    case CONFIG_CHANGED      = 'system.config.changed';
+}
diff --git a/src/Application/Security/Services/FileUploadSecurityService.php b/src/Application/Security/Services/FileUploadSecurityService.php
new file mode 100644
index 00000000..b30ab27e
--- /dev/null
+++ b/src/Application/Security/Services/FileUploadSecurityService.php
@@ -0,0 +1,125 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Application\Security\Services;
+
+use App\Application\Security\Events\File\SuspiciousFileUploadEvent;
+use App\Framework\Core\Events\EventDispatcher;
+
+final class FileUploadSecurityService
+{
+    private const ALLOWED_MIME_TYPES = [
+        'image/jpeg', 'image/png', 'image/gif', 'image/webp',
+        'application/pdf', 'text/plain', 'text/csv',
+        'application/msword', 'application/vnd.openxmlformats-officedocument.wordprocessingml.document'
+    ];
+
+    private const MAX_FILE_SIZE = 10 * 1024 * 1024; // 10MB
+
+    private const DANGEROUS_EXTENSIONS = [
+        'php', 'phtml', 'php3', 'php4', 'php5', 'pl', 'py', 'jsp', 'asp', 'sh', 'cgi',
+        'exe', 'bat', 'com', 'scr', 'vbs', 'js', 'jar', 'war'
+    ];
+
+    private const MALWARE_SIGNATURES = [
+        'eval(', 'base64_decode(', 'system(', 'exec(', 'shell_exec(',
+        '<?php', '<%', '<script', 'javascript:'
+    ];
+
+    public function __construct(
+        private EventDispatcher $eventDispatcher
+    ) {}
+
+    public function validateUpload(array $file): bool
+    {
+        $userEmail = $_SESSION['user_email'] ?? null;
+        $filename = $file['name'] ?? '';
+        $tmpName = $file['tmp_name'] ?? '';
+        $size = $file['size'] ?? 0;
+        $error = $file['error'] ?? UPLOAD_ERR_NO_FILE;
+
+        // Upload-Fehler prüfen
+        if ($error !== UPLOAD_ERR_OK) {
+            $this->dispatchSuspiciousUpload($filename, 'unknown', $size, 'upload_error', $userEmail);
+            return false;
+        }
+
+        // Dateigröße prüfen
+        if ($size > self::MAX_FILE_SIZE) {
+            $this->dispatchSuspiciousUpload($filename, 'unknown', $size, 'file_too_large', $userEmail);
+            return false;
+        }
+
+        // Dateiendung prüfen
+        $extension = strtolower(pathinfo($filename, PATHINFO_EXTENSION));
+        if (in_array($extension, self::DANGEROUS_EXTENSIONS)) {
+            $this->dispatchSuspiciousUpload($filename, 'unknown', $size, 'dangerous_extension', $userEmail);
+            return false;
+        }
+
+        // MIME-Type prüfen
+        $mimeType = mime_content_type($tmpName);
+        if (!in_array($mimeType, self::ALLOWED_MIME_TYPES)) {
+            $this->dispatchSuspiciousUpload($filename, $mimeType, $size, 'forbidden_mime_type', $userEmail);
+            return false;
+        }
+
+        // Dateiinhalt auf Malware-Signaturen prüfen
+        if ($this->containsMalwareSignatures($tmpName)) {
+            $this->dispatchSuspiciousUpload($filename, $mimeType, $size, 'malware_signatures_detected', $userEmail);
+            return false;
+        }
+
+        // Double-Extension prüfen (z.B. file.jpg.php)
+        if ($this->hasDoubleExtension($filename)) {
+            $this->dispatchSuspiciousUpload($filename, $mimeType, $size, 'double_extension', $userEmail);
+            return false;
+        }
+
+        return true;
+    }
+
+    private function containsMalwareSignatures(string $filePath): bool
+    {
+        $content = file_get_contents($filePath);
+        if ($content === false) {
+            return false;
+        }
+
+        foreach (self::MALWARE_SIGNATURES as $signature) {
+            if (stripos($content, $signature) !== false) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    private function hasDoubleExtension(string $filename): bool
+    {
+        $parts = explode('.', $filename);
+        if (count($parts) < 3) {
+            return false;
+        }
+
+        // Prüfe ob vorletzte "Extension" gefährlich ist
+        $secondLastExtension = strtolower($parts[count($parts) - 2]);
+        return in_array($secondLastExtension, self::DANGEROUS_EXTENSIONS);
+    }
+
+    private function dispatchSuspiciousUpload(
+        string $filename,
+        string $mimeType,
+        int $size,
+        string $reason,
+        ?string $userEmail
+    ): void {
+        $this->eventDispatcher->dispatch(new SuspiciousFileUploadEvent(
+            filename: $filename,
+            mimeType: $mimeType,
+            fileSize: $size,
+            suspicionReason: $reason,
+            email: $userEmail
+        ));
+    }
+}
diff --git a/src/Application/Security/Services/InputValidationService.php b/src/Application/Security/Services/InputValidationService.php
new file mode 100644
index 00000000..71145aef
--- /dev/null
+++ b/src/Application/Security/Services/InputValidationService.php
@@ -0,0 +1,125 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Application\Security\Services;
+
+use App\Application\Security\Events\Input\{
+    InputValidationFailureEvent,
+    SqlInjectionAttemptEvent,
+    XssAttemptEvent,
+    MaliciousInputDetectedEvent
+};
+use App\Framework\Core\Events\EventDispatcher;
+
+final class InputValidationService
+{
+    private const SQL_INJECTION_PATTERNS = [
+        '/(\bunion\b.*\bselect\b)/i',
+        '/(\bdrop\b.*\btable\b)/i',
+        '/(\binsert\b.*\binto\b)/i',
+        '/(\bdelete\b.*\bfrom\b)/i',
+        '/(\bupdate\b.*\bset\b)/i',
+        '/(\b(or|and)\b.*[\'"].*[\'"].*=.*[\'"].*[\'"])/i'
+    ];
+
+    private const XSS_PATTERNS = [
+        '/<script[^>]*>.*?<\/script>/is',
+        '/<iframe[^>]*>.*?<\/iframe>/is',
+        '/javascript:/i',
+        '/on\w+\s*=/i',
+        '/<object[^>]*>.*?<\/object>/is'
+    ];
+
+    public function __construct(
+        private EventDispatcher $eventDispatcher
+    ) {}
+
+    public function validateInput(string $fieldName, mixed $value, array $rules = []): bool
+    {
+        $stringValue = (string) $value;
+        $userEmail = $_SESSION['user_email'] ?? null;
+
+        // SQL Injection Detection
+        if ($this->detectSqlInjection($stringValue)) {
+            $this->eventDispatcher->dispatch(new SqlInjectionAttemptEvent(
+                attackPayload: $stringValue,
+                targetField: $fieldName,
+                detectionMethod: 'pattern_matching',
+                email: $userEmail
+            ));
+            return false;
+        }
+
+        // XSS Detection
+        if ($this->detectXss($stringValue)) {
+            $this->eventDispatcher->dispatch(new XssAttemptEvent(
+                attackPayload: $stringValue,
+                targetField: $fieldName,
+                xssType: 'reflected_xss',
+                email: $userEmail
+            ));
+            return false;
+        }
+
+        // Standard Validation Rules
+        foreach ($rules as $rule => $parameter) {
+            if (!$this->applyRule($rule, $stringValue, $parameter)) {
+                $this->eventDispatcher->dispatch(new InputValidationFailureEvent(
+                    fieldName: $fieldName,
+                    invalidValue: $stringValue,
+                    validationRule: $rule,
+                    email: $userEmail
+                ));
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    public function sanitizeInput(string $input, string $context = 'html'): string
+    {
+        return match ($context) {
+            'html' => htmlspecialchars($input, ENT_QUOTES | ENT_HTML5, 'UTF-8'),
+            'sql' => addslashes($input),
+            'url' => urlencode($input),
+            'javascript' => json_encode($input, JSON_HEX_TAG | JSON_HEX_AMP | JSON_HEX_APOS | JSON_HEX_QUOT),
+            default => filter_var($input, FILTER_SANITIZE_SPECIAL_CHARS)
+        };
+    }
+
+    private function detectSqlInjection(string $input): bool
+    {
+        foreach (self::SQL_INJECTION_PATTERNS as $pattern) {
+            if (preg_match($pattern, $input)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private function detectXss(string $input): bool
+    {
+        foreach (self::XSS_PATTERNS as $pattern) {
+            if (preg_match($pattern, $input)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private function applyRule(string $rule, string $value, mixed $parameter): bool
+    {
+        return match ($rule) {
+            'required' => !empty($value),
+            'email' => filter_var($value, FILTER_VALIDATE_EMAIL) !== false,
+            'min_length' => strlen($value) >= $parameter,
+            'max_length' => strlen($value) <= $parameter,
+            'numeric' => is_numeric($value),
+            'alpha' => ctype_alpha($value),
+            'alphanumeric' => ctype_alnum($value),
+            'url' => filter_var($value, FILTER_VALIDATE_URL) !== false,
+            default => true
+        };
+    }
+}
diff --git a/src/Application/Security/ValueObjects/MaskedEmail.php b/src/Application/Security/ValueObjects/MaskedEmail.php
new file mode 100644
index 00000000..d6eae4da
--- /dev/null
+++ b/src/Application/Security/ValueObjects/MaskedEmail.php
@@ -0,0 +1,121 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Application\Security\ValueObjects;
+
+final class MaskedEmail
+{
+    private function __construct(
+        private string $maskedValue,
+        private string $original
+    ) {}
+
+    public static function fromString(string $email): self
+    {
+        if (!filter_var($email, FILTER_VALIDATE_EMAIL)) {
+            // Nicht-E-Mail-Strings nur minimal maskieren
+            return new self(
+                self::maskGenericString($email),
+                $email
+            );
+        }
+
+        return new self(
+            self::maskEmailAddress($email),
+            $email
+        );
+    }
+
+    public static function fromStringWithStrategy(string $email, MaskingStrategy $strategy): self
+    {
+        if (!filter_var($email, FILTER_VALIDATE_EMAIL)) {
+            return new self(
+                self::maskGenericString($email),
+                $email
+            );
+        }
+
+        $maskedValue = match ($strategy) {
+            MaskingStrategy::STANDARD => self::maskEmailAddress($email),
+            MaskingStrategy::PARTIAL => self::maskEmailPartial($email),
+            MaskingStrategy::DOMAIN_ONLY => self::maskDomainOnly($email),
+            MaskingStrategy::HASH => self::hashEmail($email)
+        };
+
+        return new self($maskedValue, $email);
+    }
+
+    public function getMaskedValue(): string
+    {
+        return $this->maskedValue;
+    }
+
+    public function getOriginal(): string
+    {
+        return $this->original;
+    }
+
+    public function toString(): string
+    {
+        return $this->maskedValue;
+    }
+
+    public function __toString(): string
+    {
+        return $this->maskedValue;
+    }
+
+    private static function maskEmailAddress(string $email): string
+    {
+        [$local, $domain] = explode('@', $email, 2);
+
+        if (strlen($local) <= 2) {
+            return str_repeat('*', strlen($local)) . '@' . $domain;
+        }
+
+        $maskedLocal = substr($local, 0, 2) . str_repeat('*', strlen($local) - 2);
+        return $maskedLocal . '@' . $domain;
+    }
+
+    private static function maskEmailPartial(string $email): string
+    {
+        [$local, $domain] = explode('@', $email, 2);
+
+        if (strlen($local) <= 3) {
+            return $local[0] . str_repeat('*', max(0, strlen($local) - 1)) . '@' . $domain;
+        }
+
+        $maskedLocal = $local[0] . str_repeat('*', strlen($local) - 2) . substr($local, -1);
+        return $maskedLocal . '@' . $domain;
+    }
+
+    private static function maskDomainOnly(string $email): string
+    {
+        [$local, $domain] = explode('@', $email, 2);
+
+        // Domain verschleiern, aber Local-Part zeigen
+        $domainParts = explode('.', $domain);
+        if (count($domainParts) > 1) {
+            $tld = array_pop($domainParts);
+            $maskedDomain = str_repeat('*', strlen(implode('.', $domainParts))) . '.' . $tld;
+        } else {
+            $maskedDomain = str_repeat('*', strlen($domain));
+        }
+
+        return $local . '@' . $maskedDomain;
+    }
+
+    private static function hashEmail(string $email): string
+    {
+        return 'user_' . substr(hash('sha256', $email), 0, 8);
+    }
+
+    private static function maskGenericString(string $input): string
+    {
+        if (strlen($input) <= 3) {
+            return str_repeat('*', strlen($input));
+        }
+
+        return substr($input, 0, 2) . str_repeat('*', strlen($input) - 2);
+    }
+}
diff --git a/src/Application/Security/ValueObjects/MaskingStrategy.php b/src/Application/Security/ValueObjects/MaskingStrategy.php
new file mode 100644
index 00000000..9e22f5be
--- /dev/null
+++ b/src/Application/Security/ValueObjects/MaskingStrategy.php
@@ -0,0 +1,22 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Application\Security\ValueObjects;
+
+enum MaskingStrategy: string
+{
+    case STANDARD = 'standard';      // jo***@example.com
+    case PARTIAL = 'partial';        // j***n@example.com
+    case DOMAIN_ONLY = 'domain_only'; // john@*******.com
+    case HASH = 'hash';              // user_a1b2c3d4
+
+    public function getDescription(): string
+    {
+        return match ($this) {
+            self::STANDARD => 'Standard email masking (first 2 chars + asterisks)',
+            self::PARTIAL => 'Partial masking (first + last char visible)',
+            self::DOMAIN_ONLY => 'Mask domain only, keep local part',
+            self::HASH => 'Replace with hash-based identifier'
+        };
+    }
+}
diff --git a/src/Application/Security/ValueObjects/OWASPEventIdentifier.php b/src/Application/Security/ValueObjects/OWASPEventIdentifier.php
new file mode 100644
index 00000000..142f8853
--- /dev/null
+++ b/src/Application/Security/ValueObjects/OWASPEventIdentifier.php
@@ -0,0 +1,119 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Application\Security\ValueObjects;
+
+final class OWASPEventIdentifier
+{
+    private function __construct(
+        private string $category,
+        private string $action,
+        private ?string $subject = null
+    ) {}
+
+    public static function authenticationSuccess(string $username): self
+    {
+        return new self('AUTHN', 'login_success', $username);
+    }
+
+    public static function authenticationFailure(string $username): self
+    {
+        return new self('AUTHN', 'login_failure', $username);
+    }
+
+    public static function sessionTermination(string $username): self
+    {
+        return new self('AUTHN', 'logout', $username);
+    }
+
+    public static function passwordChange(string $username): self
+    {
+        return new self('AUTHN', 'password_change', $username);
+    }
+
+    public static function accountLocked(string $username): self
+    {
+        return new self('AUTHN', 'account_locked', $username);
+    }
+
+    public static function authorizationFailure(string $username, string $resource): self
+    {
+        return new self('AUTHZ', 'access_denied', "{$username}:{$resource}");
+    }
+
+    public static function privilegeEscalation(string $username, string $fromRole, string $toRole): self
+    {
+        return new self('AUTHZ', 'privilege_escalation', "{$username}:{$fromRole}>{$toRole}");
+    }
+
+    public static function inputValidationFailure(string $field): self
+    {
+        return new self('INPUT', 'validation_failure', $field);
+    }
+
+    public static function maliciousInput(string $attackType): self
+    {
+        return new self('INPUT', 'malicious_input', $attackType);
+    }
+
+    public static function fileUploadFailure(string $filename): self
+    {
+        return new self('INPUT', 'file_upload_failure', $filename);
+    }
+
+    public static function sessionHijacking(string $username): self
+    {
+        return new self('SESS', 'session_hijacking', $username);
+    }
+
+    public static function sessionTimeout(string $username): self
+    {
+        return new self('SESS', 'session_timeout', $username);
+    }
+
+    public static function malwareDetected(string $malwareType): self
+    {
+        return new self('MALICIOUS', 'malware_detected', $malwareType);
+    }
+
+    public static function auditFailure(string $eventType): self
+    {
+        return new self('AUDIT', 'audit_failure', $eventType);
+    }
+
+    public static function sessionFixation(string $username): self
+    {
+        return new self('SESS', 'session_fixation', $username);
+    }
+
+    public static function cryptographicFailure(string $operation): self
+    {
+        return new self('CRYPTO', 'crypto_failure', $operation);
+    }
+
+    public static function suspiciousNetworkActivity(string $activityType): self
+    {
+        return new self('NETWORK', 'suspicious_activity', $activityType);
+    }
+
+    public static function systemAnomaly(string $anomalyType): self
+    {
+        return new self('SYSTEM', 'anomaly_detected', $anomalyType);
+    }
+
+    public static function csrfViolation(string $requestPath): self
+    {
+        return new self('WEB', 'csrf_violation', $requestPath);
+    }
+
+    public function toString(): string
+    {
+        $identifier = "{$this->category}_{$this->action}";
+
+        if ($this->subject !== null) {
+            $identifier .= ":{$this->subject}";
+        }
+
+        return $identifier;
+    }
+}
diff --git a/src/Application/Security/ValueObjects/OWASPLogFormat.php b/src/Application/Security/ValueObjects/OWASPLogFormat.php
new file mode 100644
index 00000000..a6d5234e
--- /dev/null
+++ b/src/Application/Security/ValueObjects/OWASPLogFormat.php
@@ -0,0 +1,110 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Application\Security\ValueObjects;
+
+use DateTimeImmutable;
+use DateTimeInterface;
+
+final class OWASPLogFormat
+{
+    public function __construct(
+        private DateTimeImmutable $datetime,
+        private string $appid,
+        private string $event,
+        private string $level,
+        private string $description,
+        private ?string $useragent = null,
+        private ?string $sourceIp = null,
+        private ?string $hostIp = null,
+        private ?string $hostname = null,
+        private ?string $protocol = null,
+        private ?string $port = null,
+        private ?string $requestUri = null,
+        private ?string $requestMethod = null,
+        private ?string $region = null,
+        private ?string $geo = null
+    ) {}
+
+    public static function create(
+        string $appid,
+        string $event,
+        string $level,
+        string $description,
+        SecurityContext $context,
+        RequestContext $requestContext
+    ): self {
+        return new self(
+            new DateTimeImmutable(),
+            $appid,
+            $event,
+            $level,
+            $description,
+            $context->getUserAgent(),
+            $context->getSourceIp(),
+            $requestContext->getHostIp(),
+            $requestContext->getHostname(),
+            $requestContext->getProtocol(),
+            $requestContext->getPort(),
+            $requestContext->getRequestUri(),
+            $requestContext->getRequestMethod(),
+            $requestContext->getRegion(),
+            $requestContext->getGeo()
+        );
+    }
+
+    public function toArray(): array
+    {
+        $data = [
+            'datetime' => $this->datetime->format(DateTimeInterface::ATOM),
+            'appid' => $this->appid,
+            'event' => $this->event,
+            'level' => $this->level,
+            'description' => $this->description
+        ];
+
+        // Nur nicht-null Werte hinzufügen
+        if ($this->useragent !== null) {
+            $data['useragent'] = $this->useragent;
+        }
+        if ($this->sourceIp !== null) {
+            $data['source_ip'] = $this->sourceIp;
+        }
+        if ($this->hostIp !== null) {
+            $data['host_ip'] = $this->hostIp;
+        }
+        if ($this->hostname !== null) {
+            $data['hostname'] = $this->hostname;
+        }
+        if ($this->protocol !== null) {
+            $data['protocol'] = $this->protocol;
+        }
+        if ($this->port !== null) {
+            $data['port'] = $this->port;
+        }
+        if ($this->requestUri !== null) {
+            $data['request_uri'] = $this->requestUri;
+        }
+        if ($this->requestMethod !== null) {
+            $data['request_method'] = $this->requestMethod;
+        }
+        if ($this->region !== null) {
+            $data['region'] = $this->region;
+        }
+        if ($this->geo !== null) {
+            $data['geo'] = $this->geo;
+        }
+
+        return $data;
+    }
+
+    public function toJson(): string
+    {
+        return json_encode($this->toArray(), JSON_THROW_ON_ERROR | JSON_UNESCAPED_SLASHES);
+    }
+
+    public function getDescription(): string
+    {
+        return $this->description;
+    }
+}
diff --git a/src/Application/Security/ValueObjects/OWASPLogLevel.php b/src/Application/Security/ValueObjects/OWASPLogLevel.php
new file mode 100644
index 00000000..dc9e5924
--- /dev/null
+++ b/src/Application/Security/ValueObjects/OWASPLogLevel.php
@@ -0,0 +1,39 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Application\Security\ValueObjects;
+
+use App\Application\Security\SecurityEventType;
+
+enum OWASPLogLevel: string
+{
+    case DEBUG = 'DEBUG';
+    case INFO = 'INFO';
+    case WARN = 'WARN';
+    case ERROR = 'ERROR';
+    case FATAL = 'FATAL';
+
+    public static function fromSecurityEventType(SecurityEventType $type): self
+    {
+        return match ($type) {
+            SecurityEventType::LOGIN_SUCCESS,
+            SecurityEventType::LOGOUT,
+            SecurityEventType::PASSWORD_CHANGE => self::INFO,
+
+            SecurityEventType::LOGIN_FAILED,
+            SecurityEventType::ACCESS_DENIED,
+            SecurityEventType::SESSION_TIMEOUT => self::WARN,
+
+            SecurityEventType::INJECTION_ATTEMPT,
+            SecurityEventType::MALWARE_DETECTED,
+            SecurityEventType::ACCOUNT_LOCKED,
+            SecurityEventType::FILE_UPLOAD => self::ERROR,
+
+            SecurityEventType::PRIVILEGE_ESCALATION,
+            SecurityEventType::SESSION_HIJACK,
+            SecurityEventType::AUDIT_FAILURE => self::FATAL,
+
+            default => self::INFO
+        };
+    }
+}
diff --git a/src/Application/Security/ValueObjects/RequestContext.php b/src/Application/Security/ValueObjects/RequestContext.php
new file mode 100644
index 00000000..c448799e
--- /dev/null
+++ b/src/Application/Security/ValueObjects/RequestContext.php
@@ -0,0 +1,72 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Application\Security\ValueObjects;
+
+final class RequestContext
+{
+    private function __construct(
+        private ?string $hostIp,
+        private ?string $hostname,
+        private ?string $protocol,
+        private ?string $port,
+        private ?string $requestUri,
+        private ?string $requestMethod,
+        private ?string $region,
+        private ?string $geo
+    ) {}
+
+    public static function fromGlobals(): self
+    {
+        return new self(
+            $_SERVER['SERVER_ADDR'] ?? null,
+            $_SERVER['HTTP_HOST'] ?? $_SERVER['SERVER_NAME'] ?? null,
+            isset($_SERVER['HTTPS']) && $_SERVER['HTTPS'] !== 'off' ? 'https' : 'http',
+            $_SERVER['SERVER_PORT'] ?? null,
+            $_SERVER['REQUEST_URI'] ?? null,
+            $_SERVER['REQUEST_METHOD'] ?? null,
+            $_ENV['AWS_REGION'] ?? $_ENV['REGION'] ?? null,
+            $_ENV['GEO_REGION'] ?? null
+        );
+    }
+
+    public function getHostIp(): ?string
+    {
+        return $this->hostIp;
+    }
+
+    public function getHostname(): ?string
+    {
+        return $this->hostname;
+    }
+
+    public function getProtocol(): ?string
+    {
+        return $this->protocol;
+    }
+
+    public function getPort(): ?string
+    {
+        return $this->port;
+    }
+
+    public function getRequestUri(): ?string
+    {
+        return $this->requestUri;
+    }
+
+    public function getRequestMethod(): ?string
+    {
+        return $this->requestMethod;
+    }
+
+    public function getRegion(): ?string
+    {
+        return $this->region;
+    }
+
+    public function getGeo(): ?string
+    {
+        return $this->geo;
+    }
+}
diff --git a/src/Application/Security/ValueObjects/SecurityContext.php b/src/Application/Security/ValueObjects/SecurityContext.php
new file mode 100644
index 00000000..2c254204
--- /dev/null
+++ b/src/Application/Security/ValueObjects/SecurityContext.php
@@ -0,0 +1,77 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Application\Security\ValueObjects;
+
+use DateTimeImmutable;
+
+final class SecurityContext
+{
+    private function __construct(
+        private ?string $sourceIp,
+        private ?string $userAgent,
+        private ?string $sessionId,
+        private ?string $requestId,
+        private ?string $userId,
+        private DateTimeImmutable $timestamp
+    ) {}
+
+    public static function fromGlobals(): self
+    {
+        return new self(
+            $_SERVER['REMOTE_ADDR'] ?? null,
+            $_SERVER['HTTP_USER_AGENT'] ?? null,
+            session_id() ?: null,
+            $_SERVER['HTTP_X_REQUEST_ID'] ?? null,
+            $_SESSION['user_id'] ?? null,
+            new DateTimeImmutable()
+        );
+    }
+
+    public static function create(
+        ?string $sourceIp = null,
+        ?string $userAgent = null,
+        ?string $sessionId = null,
+        ?string $requestId = null,
+        ?string $userId = null
+    ): self {
+        return new self(
+            $sourceIp,
+            $userAgent,
+            $sessionId,
+            $requestId,
+            $userId,
+            new DateTimeImmutable()
+        );
+    }
+
+    public function getSourceIp(): ?string
+    {
+        return $this->sourceIp;
+    }
+
+    public function getUserAgent(): ?string
+    {
+        return $this->userAgent;
+    }
+
+    public function getSessionId(): ?string
+    {
+        return $this->sessionId;
+    }
+
+    public function getRequestId(): ?string
+    {
+        return $this->requestId;
+    }
+
+    public function getUserId(): ?string
+    {
+        return $this->userId;
+    }
+
+    public function getTimestamp(): DateTimeImmutable
+    {
+        return $this->timestamp;
+    }
+}
diff --git a/src/Application/Service/QrCodeService.php b/src/Application/Service/QrCodeService.php
new file mode 100644
index 00000000..8817192c
--- /dev/null
+++ b/src/Application/Service/QrCodeService.php
@@ -0,0 +1,102 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Application\Service;
+
+use App\Domain\QrCode\QrCode;
+use App\Domain\QrCode\Service\QrCodeEncoder;
+use App\Domain\QrCode\Service\QrCodeGenerator;
+use App\Domain\QrCode\Service\QrCodeRenderer;
+use App\Domain\QrCode\ValueObject\ErrorCorrectionLevel;
+use App\Domain\QrCode\ValueObject\QrCodeConfig;
+use App\Domain\QrCode\ValueObject\QrCodeMatrix;
+use App\Domain\QrCode\ValueObject\QrCodeVersion;
+
+readonly class QrCodeService
+{
+    public function __construct(
+        private QrCodeGenerator $generator
+    ) {
+    }
+
+    /**
+     * Generiert einen QR-Code für die angegebenen Daten
+     *
+     * @param string $data Die zu kodierenden Daten
+     * @param ErrorCorrectionLevel $errorLevel Fehlerkorrektur-Level
+     * @param int|null $version Spezifische QR-Code-Version (optional)
+     * @return QrCodeMatrix Die generierte QR-Code-Matrix
+     */
+    public function generateQrCode(
+        string $data,
+        ErrorCorrectionLevel $errorLevel = ErrorCorrectionLevel::M,
+        ?int $version = null
+    ): QrCodeMatrix {
+        $qrCodeVersion = $version ? new QrCodeVersion($version) : null;
+        $qrCode = new QrCode($data, $errorLevel, $qrCodeVersion);
+
+        return $this->generator->generate($qrCode);
+    }
+
+    /**
+     * Generiert einen QR-Code als SVG
+     *
+     * @param string $data Die zu kodierenden Daten
+     * @param ErrorCorrectionLevel $errorLevel Fehlerkorrektur-Level
+     * @param QrCodeConfig|null $config Konfigurationseinstellungen
+     * @return string SVG-Darstellung des QR-Codes
+     */
+    public function generateSvg(
+        string $data,
+        ErrorCorrectionLevel $errorLevel = ErrorCorrectionLevel::M,
+        ?QrCodeConfig $config = null
+    ): string {
+        $matrix = $this->generateQrCode($data, $errorLevel);
+        $config = $config ?? new QrCodeConfig();
+
+        return $matrix->toSvg(
+            $config->getModuleSize(),
+            $config->getMargin(),
+            $config->getForegroundColor(),
+            $config->getBackgroundColor()
+        );
+    }
+
+    /**
+     * Generiert einen QR-Code als PNG
+     *
+     * @param string $data Die zu kodierenden Daten
+     * @param ErrorCorrectionLevel $errorLevel Fehlerkorrektur-Level
+     * @param QrCodeConfig|null $config Konfigurationseinstellungen
+     * @return string PNG-Binärdaten des QR-Codes
+     */
+    public function generatePng(
+        string $data,
+        ErrorCorrectionLevel $errorLevel = ErrorCorrectionLevel::M,
+        ?QrCodeConfig $config = null
+    ): string {
+        $matrix = $this->generateQrCode($data, $errorLevel);
+        $config = $config ?? new QrCodeConfig();
+
+        return $matrix->toPng(
+            $config->getModuleSize(),
+            $config->getMargin()
+        );
+    }
+
+    /**
+     * Generiert einen QR-Code als ASCII-Art
+     *
+     * @param string $data Die zu kodierenden Daten
+     * @param ErrorCorrectionLevel $errorLevel Fehlerkorrektur-Level
+     * @return string ASCII-Darstellung des QR-Codes
+     */
+    public function generateAscii(
+        string $data,
+        ErrorCorrectionLevel $errorLevel = ErrorCorrectionLevel::M
+    ): string {
+        $matrix = $this->generateQrCode($data, $errorLevel);
+        return $matrix->toAscii();
+    }
+}
diff --git a/src/Application/Shopify/CustomerController.php b/src/Application/Shopify/CustomerController.php
new file mode 100644
index 00000000..2d6ea586
--- /dev/null
+++ b/src/Application/Shopify/CustomerController.php
@@ -0,0 +1,117 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Application\Shopify;
+
+use App\Framework\Api\ApiException;
+use App\Framework\Attributes\Route;
+use App\Framework\Http\Method;
+use App\Framework\Http\Status;
+use App\Framework\Router\Result\JsonResult;
+use App\Infrastructure\Api\ShopifyClient;
+use Archive\Config\ApiConfig;
+
+final class CustomerController
+{
+    private ShopifyClient $client;
+
+    public function __construct()
+    {
+        $this->client = new ShopifyClient(
+            ApiConfig::SHOPIFY_SHOP_DOMAIN->value,
+            ApiConfig::SHOPIFY_ACCESS_TOKEN->value,
+            ApiConfig::SHOPIFY_API_VERSION->value
+        );
+    }
+
+    /**
+     * Ruft alle Kunden ab
+     */
+    #[Route(path: '/api/shopify/customers', method: Method::GET)]
+    public function listCustomers(): JsonResult
+    {
+        try {
+            $options = [
+                'limit' => 50,
+                'fields' => 'id,email,first_name,last_name,orders_count,total_spent'
+            ];
+
+            $customers = $this->client->getCustomers($options);
+
+            return new JsonResult([
+                'success' => true,
+                'data' => $customers
+            ]);
+        } catch (ApiException $e) {
+            $result = new JsonResult([
+                'success' => false,
+                'error' => $e->getMessage()
+            ]);
+            $result->status = Status::from($e->getCode() ?: 500);
+            return $result;
+        }
+    }
+
+    /**
+     * Ruft einen einzelnen Kunden ab
+     */
+    #[Route(path: '/api/shopify/customers/{id}', method: Method::GET)]
+    public function getCustomer(int $id): JsonResult
+    {
+        try {
+            $customer = $this->client->getCustomer($id);
+
+            return new JsonResult([
+                'success' => true,
+                'data' => $customer
+            ]);
+        } catch (ApiException $e) {
+            $result = new JsonResult([
+                'success' => false,
+                'error' => $e->getMessage()
+            ]);
+            $result->status = Status::from($e->getCode() ?: 500);
+            return $result;
+        }
+    }
+
+    /**
+     * Erstellt einen neuen Kunden
+     */
+    #[Route(path: '/api/shopify/customers', method: Method::POST)]
+    public function createCustomer(CustomerRequest $request): JsonResult
+    {
+        try {
+            $customerData = [
+                'first_name' => $request->firstName,
+                'last_name' => $request->lastName,
+                'email' => $request->email,
+                'phone' => $request->phone ?? null,
+                'verified_email' => $request->verifiedEmail ?? true,
+                'addresses' => $request->addresses ?? [],
+                'password' => $request->password ?? null,
+                'password_confirmation' => $request->password ?? null,
+                'send_email_welcome' => $request->sendWelcomeEmail ?? false
+            ];
+
+            // Entferne leere Felder
+            $customerData = array_filter($customerData, fn($value) => $value !== null);
+
+            $customer = $this->client->createCustomer($customerData);
+
+            $result = new JsonResult([
+                'success' => true,
+                'data' => $customer
+            ]);
+            $result->status = Status::CREATED;
+            return $result;
+        } catch (ApiException $e) {
+            $result = new JsonResult([
+                'success' => false,
+                'error' => $e->getMessage()
+            ]);
+            $result->status = Status::from($e->getCode() ?: 500);
+            return $result;
+        }
+    }
+}
diff --git a/src/Application/Shopify/CustomerRequest.php b/src/Application/Shopify/CustomerRequest.php
new file mode 100644
index 00000000..765d240f
--- /dev/null
+++ b/src/Application/Shopify/CustomerRequest.php
@@ -0,0 +1,18 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Application\Shopify;
+
+final readonly class CustomerRequest
+{
+    public function __construct(
+        public string  $firstName,
+        public string  $lastName,
+        public string  $email,
+        public ?string $phone = null,
+        public ?bool   $verifiedEmail = null,
+        public ?array  $addresses = null,
+        public ?string $password = null,
+        public ?bool   $sendWelcomeEmail = null
+    ) {}
+}
diff --git a/src/Application/Shopify/OrderController.php b/src/Application/Shopify/OrderController.php
new file mode 100644
index 00000000..30d9774a
--- /dev/null
+++ b/src/Application/Shopify/OrderController.php
@@ -0,0 +1,118 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Application\Shopify;
+
+use App\Framework\Api\ApiException;
+use App\Framework\Attributes\Route;
+use App\Framework\Http\Method;
+use App\Framework\Http\Status;
+use App\Framework\Router\Result\JsonResult;
+use App\Infrastructure\Api\ShopifyClient;
+use Archive\Config\ApiConfig;
+
+final class OrderController
+{
+    private ShopifyClient $client;
+
+    public function __construct()
+    {
+        $this->client = new ShopifyClient(
+            ApiConfig::SHOPIFY_SHOP_DOMAIN->value,
+            ApiConfig::SHOPIFY_ACCESS_TOKEN->value,
+            ApiConfig::SHOPIFY_API_VERSION->value
+        );
+    }
+
+    /**
+     * Ruft alle Bestellungen ab
+     */
+    #[Route(path: '/api/shopify/orders', method: Method::GET)]
+    public function listOrders(): JsonResult
+    {
+        try {
+            $options = [
+                'limit' => 50,
+                'status' => 'any',
+                'fields' => 'id,order_number,customer,total_price,created_at,financial_status'
+            ];
+
+            $orders = $this->client->getOrders($options);
+
+            return new JsonResult([
+                'success' => true,
+                'data' => $orders
+            ]);
+        } catch (ApiException $e) {
+            $result = new JsonResult([
+                'success' => false,
+                'error' => $e->getMessage()
+            ]);
+            $result->status = Status::from($e->getCode() ?: 500);
+            return $result;
+        }
+    }
+
+    /**
+     * Ruft eine einzelne Bestellung ab
+     */
+    #[Route(path: '/api/shopify/orders/{id}', method: Method::GET)]
+    public function getOrder(int $id): JsonResult
+    {
+        try {
+            $order = $this->client->getOrder($id);
+
+            return new JsonResult([
+                'success' => true,
+                'data' => $order
+            ]);
+        } catch (ApiException $e) {
+            $result = new JsonResult([
+                'success' => false,
+                'error' => $e->getMessage()
+            ]);
+            $result->status = Status::from($e->getCode() ?: 500);
+            return $result;
+        }
+    }
+
+    /**
+     * Erstellt eine neue Bestellung
+     */
+    #[Route(path: '/api/shopify/orders', method: Method::POST)]
+    public function createOrder(OrderRequest $request): JsonResult
+    {
+        try {
+            $orderData = [
+                'line_items' => $request->lineItems,
+                'customer' => $request->customer ?? null,
+                'shipping_address' => $request->shippingAddress ?? null,
+                'billing_address' => $request->billingAddress ?? null,
+                'financial_status' => $request->financialStatus ?? 'pending',
+                'fulfillment_status' => $request->fulfillmentStatus ?? null,
+                'tags' => $request->tags ?? '',
+                'note' => $request->note ?? null,
+                'email' => $request->email ?? null
+            ];
+
+            // Entferne leere Felder
+            $orderData = array_filter($orderData, fn($value) => $value !== null);
+
+            $order = $this->client->createOrder($orderData);
+
+            $result = new JsonResult([
+                'success' => true,
+                'data' => $order
+            ]);
+            $result->status = Status::CREATED;
+            return $result;
+        } catch (ApiException $e) {
+            $result = new JsonResult([
+                'success' => false,
+                'error' => $e->getMessage()
+            ]);
+            $result->status = Status::from($e->getCode() ?: 500);
+            return $result;
+        }
+    }
+}
diff --git a/src/Application/Shopify/OrderRequest.php b/src/Application/Shopify/OrderRequest.php
new file mode 100644
index 00000000..c3db3399
--- /dev/null
+++ b/src/Application/Shopify/OrderRequest.php
@@ -0,0 +1,19 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Application\Shopify;
+
+final class OrderRequest
+{
+    public function __construct(
+        public readonly array $lineItems,
+        public readonly ?array $customer = null,
+        public readonly ?array $shippingAddress = null,
+        public readonly ?array $billingAddress = null,
+        public readonly ?string $financialStatus = null,
+        public readonly ?string $fulfillmentStatus = null,
+        public readonly ?string $tags = null,
+        public readonly ?string $note = null,
+        public readonly ?string $email = null
+    ) {}
+}
diff --git a/src/Application/Shopify/ProductController.php b/src/Application/Shopify/ProductController.php
new file mode 100644
index 00000000..1775ae67
--- /dev/null
+++ b/src/Application/Shopify/ProductController.php
@@ -0,0 +1,192 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Application\Shopify;
+
+use App\Framework\Api\ApiException;
+use App\Framework\Attributes\Route;
+use App\Framework\Http\Method;
+use App\Framework\Http\Status;
+use App\Framework\Router\Result\JsonResult;
+use App\Infrastructure\Api\ShopifyClient;
+use Archive\Config\ApiConfig;
+
+final class ProductController
+{
+    private ShopifyClient $client;
+
+    public function __construct()
+    {
+        $this->client = new ShopifyClient(
+            ApiConfig::SHOPIFY_SHOP_DOMAIN->value,
+            ApiConfig::SHOPIFY_ACCESS_TOKEN->value,
+            ApiConfig::SHOPIFY_API_VERSION->value
+        );
+    }
+
+    /**
+     * Ruft alle Produkte aus dem Shopify-Shop ab
+     */
+    #[Route(path: '/api/shopify/products', method: Method::GET)]
+    public function listProducts(): JsonResult
+    {
+        try {
+            $options = [
+                'limit' => 50,
+                'fields' => 'id,title,variants,images,status,published_at'
+            ];
+
+            $products = $this->client->getProducts($options);
+
+            return new JsonResult([
+                'success' => true,
+                'data' => $products
+            ]);
+        } catch (ApiException $e) {
+            $result = new JsonResult([
+                'success' => false,
+                'error' => $e->getMessage()
+            ]);
+            $result->status = Status::from($e->getCode() ?: 500);
+            return $result;
+        }
+    }
+
+    /**
+     * Ruft ein einzelnes Produkt anhand seiner ID ab
+     */
+    #[Route(path: '/api/shopify/products/{id}', method: Method::GET)]
+    public function getProduct(int $id): JsonResult
+    {
+        try {
+            $product = $this->client->getProduct($id);
+
+            return new JsonResult([
+                'success' => true,
+                'data' => $product
+            ]);
+        } catch (ApiException $e) {
+            $result = new JsonResult([
+                'success' => false,
+                'error' => $e->getMessage()
+            ]);
+            $result->status = Status::from($e->getCode() ?: 500);
+            return $result;
+        }
+    }
+
+    /**
+     * Erstellt ein neues Produkt
+     */
+    #[Route(path: '/api/shopify/products', method: Method::POST)]
+    public function createProduct(ProductRequest $request): JsonResult
+    {
+        try {
+            $product = $this->client->createProduct([
+                'title' => $request->title,
+                'body_html' => $request->description ?? '',
+                'vendor' => $request->vendor ?? 'Custom Shop',
+                'product_type' => $request->productType ?? '',
+                'tags' => $request->tags ?? '',
+                'variants' => $request->variants ?? [],
+                'options' => $request->options ?? [],
+                'images' => $request->images ?? []
+            ]);
+
+            $result = new JsonResult([
+                'success' => true,
+                'data' => $product
+            ]);
+            $result->status = Status::CREATED;
+            return $result;
+        } catch (ApiException $e) {
+            $result = new JsonResult([
+                'success' => false,
+                'error' => $e->getMessage()
+            ]);
+            $result->status = Status::from($e->getCode() ?: 500);
+            return $result;
+        }
+    }
+
+    /**
+     * Aktualisiert ein bestehendes Produkt
+     */
+    #[Route(path: '/api/shopify/products/{id}', method: Method::PUT)]
+    public function updateProduct(int $id, ProductRequest $request): JsonResult
+    {
+        try {
+            $productData = [];
+
+            // Nur die Felder aktualisieren, die tatsächlich im Request enthalten sind
+            if (isset($request->title)) $productData['title'] = $request->title;
+            if (isset($request->description)) $productData['body_html'] = $request->description;
+            if (isset($request->vendor)) $productData['vendor'] = $request->vendor;
+            if (isset($request->productType)) $productData['product_type'] = $request->productType;
+            if (isset($request->tags)) $productData['tags'] = $request->tags;
+            if (isset($request->variants)) $productData['variants'] = $request->variants;
+            if (isset($request->options)) $productData['options'] = $request->options;
+            if (isset($request->images)) $productData['images'] = $request->images;
+
+            $product = $this->client->updateProduct($id, $productData);
+
+            return new JsonResult([
+                'success' => true,
+                'data' => $product
+            ]);
+        } catch (ApiException $e) {
+            $result = new JsonResult([
+                'success' => false,
+                'error' => $e->getMessage()
+            ]);
+            $result->status = Status::from($e->getCode() ?: 500);
+            return $result;
+        }
+    }
+
+    /**
+     * Löscht ein Produkt
+     */
+    #[Route(path: '/api/shopify/products/{id}', method: Method::DELETE)]
+    public function deleteProduct(int $id): JsonResult
+    {
+        try {
+            $success = $this->client->deleteProduct($id);
+
+            return new JsonResult([
+                'success' => $success,
+                'message' => $success ? 'Produkt erfolgreich gelöscht' : 'Produkt konnte nicht gelöscht werden'
+            ]);
+        } catch (ApiException $e) {
+            $result = new JsonResult([
+                'success' => false,
+                'error' => $e->getMessage()
+            ]);
+            $result->status = Status::from($e->getCode() ?: 500);
+            return $result;
+        }
+    }
+
+    /**
+     * Sucht nach Produkten
+     */
+    #[Route(path: '/api/shopify/products/search', method: Method::GET)]
+    public function searchProducts(string $query): JsonResult
+    {
+        try {
+            $products = $this->client->searchProducts($query);
+
+            return new JsonResult([
+                'success' => true,
+                'data' => $products
+            ]);
+        } catch (ApiException $e) {
+            $result = new JsonResult([
+                'success' => false,
+                'error' => $e->getMessage()
+            ]);
+            $result->status = Status::from($e->getCode() ?: 500);
+            return $result;
+        }
+    }
+}
diff --git a/src/Application/Shopify/ProductRequest.php b/src/Application/Shopify/ProductRequest.php
new file mode 100644
index 00000000..37faf622
--- /dev/null
+++ b/src/Application/Shopify/ProductRequest.php
@@ -0,0 +1,18 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Application\Shopify;
+
+final class ProductRequest
+{
+    public function __construct(
+        public readonly string $title,
+        public readonly ?string $description = null,
+        public readonly ?string $vendor = null,
+        public readonly ?string $productType = null,
+        public readonly ?string $tags = null,
+        public readonly ?array $variants = null,
+        public readonly ?array $options = null,
+        public readonly ?array $images = null
+    ) {}
+}
diff --git a/src/Application/Shopify/ShopController.php b/src/Application/Shopify/ShopController.php
new file mode 100644
index 00000000..9bbe9063
--- /dev/null
+++ b/src/Application/Shopify/ShopController.php
@@ -0,0 +1,101 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Application\Shopify;
+
+use App\Framework\Api\ApiException;
+use App\Framework\Attributes\Route;
+use App\Framework\Http\Method;
+use App\Framework\Http\Status;
+use App\Framework\Router\Result\JsonResult;
+use App\Infrastructure\Api\ShopifyClient;
+use Archive\Config\ApiConfig;
+
+final class ShopController
+{
+    private ShopifyClient $client;
+
+    public function __construct()
+    {
+        $this->client = new ShopifyClient(
+            ApiConfig::SHOPIFY_SHOP_DOMAIN->value,
+            ApiConfig::SHOPIFY_ACCESS_TOKEN->value,
+            ApiConfig::SHOPIFY_API_VERSION->value
+        );
+    }
+
+    /**
+     * Ruft Informationen über den Shop ab
+     */
+    #[Route(path: '/api/shopify/shop', method: Method::GET)]
+    public function getShopInfo(): JsonResult
+    {
+        try {
+            $shopInfo = $this->client->getShopInfo();
+
+            return new JsonResult([
+                'success' => true,
+                'data' => $shopInfo
+            ]);
+        } catch (ApiException $e) {
+            $result = new JsonResult([
+                'success' => false,
+                'error' => $e->getMessage()
+            ]);
+            $result->status = Status::from($e->getCode() ?: 500);
+            return $result;
+        }
+    }
+
+    /**
+     * Ruft die Webhooks des Shops ab
+     */
+    #[Route(path: '/api/shopify/webhooks', method: Method::GET)]
+    public function getWebhooks(): JsonResult
+    {
+        try {
+            $webhooks = $this->client->getWebhooks();
+
+            return new JsonResult([
+                'success' => true,
+                'data' => $webhooks
+            ]);
+        } catch (ApiException $e) {
+            $result = new JsonResult([
+                'success' => false,
+                'error' => $e->getMessage()
+            ]);
+            $result->status = Status::from($e->getCode() ?: 500);
+            return $result;
+        }
+    }
+
+    /**
+     * Erstellt einen neuen Webhook
+     */
+    #[Route(path: '/api/shopify/webhooks', method: Method::POST)]
+    public function createWebhook(WebhookRequest $request): JsonResult
+    {
+        try {
+            $webhook = $this->client->createWebhook(
+                $request->topic,
+                $request->address,
+                $request->format ?? 'json'
+            );
+
+            $result = new JsonResult([
+                'success' => true,
+                'data' => $webhook
+            ]);
+            $result->status = Status::CREATED;
+            return $result;
+        } catch (ApiException $e) {
+            $result = new JsonResult([
+                'success' => false,
+                'error' => $e->getMessage()
+            ]);
+            $result->status = Status::from($e->getCode() ?: 500);
+            return $result;
+        }
+    }
+}
diff --git a/src/Application/Shopify/ShopifyWebhookHandler.php b/src/Application/Shopify/ShopifyWebhookHandler.php
new file mode 100644
index 00000000..055d5dda
--- /dev/null
+++ b/src/Application/Shopify/ShopifyWebhookHandler.php
@@ -0,0 +1,103 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Application\Shopify;
+
+use App\Framework\Attributes\Route;
+use App\Framework\Http\Method;
+use App\Framework\Http\Request;
+use App\Framework\Http\Status;
+use App\Framework\Router\Result\JsonResult;
+
+final class ShopifyWebhookHandler
+{
+    /**
+     * Verarbeitet eingehende Shopify-Webhooks
+     *
+     * Hinweis: Shopify überprüft die Authentizität von Webhooks mit dem X-Shopify-Hmac-Sha256 Header
+     */
+    #[Route(path: '/webhook/shopify', method: Method::POST)]
+    public function handleWebhook(Request $request): JsonResult
+    {
+        // Webhook-Thema aus dem Header lesen
+        $topic = $request->headers->get('X-Shopify-Topic')[0] ?? null;
+        $shopDomain = $request->headers->get('X-Shopify-Shop-Domain')[0] ?? null;
+        $hmac = $request->headers->get('X-Shopify-Hmac-Sha256')[0] ?? null;
+
+        // Validiere den HMAC, um sicherzustellen, dass der Request von Shopify kommt
+        $rawData = $request->body;
+
+        if (!$this->validateWebhookHmac($hmac, $rawData)) {
+            $result = new JsonResult(['error' => 'Ungültiger HMAC']);
+            $result->status = Status::UNAUTHORIZED;
+            return $result;
+        }
+
+        // Daten verarbeiten
+        $data = json_decode($rawData, true);
+
+        // Je nach Topic unterschiedlich verarbeiten
+        switch ($topic) {
+            case 'orders/create':
+                $this->processOrderCreated($data);
+                break;
+            case 'products/create':
+            case 'products/update':
+                $this->processProductUpdate($data);
+                break;
+            case 'customers/create':
+                $this->processCustomerCreated($data);
+                break;
+            // Weitere Webhook-Themen...
+            default:
+                // Unbekanntes Thema, loggen oder ignorieren
+                break;
+        }
+
+        // Shopify erwartet eine erfolgreiche Antwort (2xx)
+        return new JsonResult(['success' => true]);
+    }
+
+    /**
+     * Validiert den HMAC-Header
+     */
+    private function validateWebhookHmac(?string $hmac, string $data): bool
+    {
+        if (!$hmac) {
+            return false;
+        }
+
+        // Das Shared Secret sollte eigentlich in ApiConfig sein
+        $secret = 'dein_webhook_shared_secret'; // ODER aus ApiConfig holen
+        $calculatedHmac = base64_encode(hash_hmac('sha256', $data, $secret, true));
+
+        return hash_equals($calculatedHmac, $hmac);
+    }
+
+    /**
+     * Verarbeitet eine neu erstellte Bestellung
+     */
+    private function processOrderCreated(array $orderData): void
+    {
+        // Hier die Logik für neue Bestellungen implementieren
+        // z.B. in eigenes System übertragen, E-Mails versenden, etc.
+    }
+
+    /**
+     * Verarbeitet Produkt-Updates
+     */
+    private function processProductUpdate(array $productData): void
+    {
+        // Hier die Logik für Produkt-Updates implementieren
+        // z.B. Lagerbestand in eigenem System aktualisieren
+    }
+
+    /**
+     * Verarbeitet einen neu erstellten Kunden
+     */
+    private function processCustomerCreated(array $customerData): void
+    {
+        // Hier die Logik für neue Kunden implementieren
+        // z.B. in CRM-System übertragen, Newsletter-Anmeldung
+    }
+}
diff --git a/src/Application/Shopify/WebhookRequest.php b/src/Application/Shopify/WebhookRequest.php
new file mode 100644
index 00000000..785197e8
--- /dev/null
+++ b/src/Application/Shopify/WebhookRequest.php
@@ -0,0 +1,13 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Application\Shopify;
+
+final class WebhookRequest
+{
+    public function __construct(
+        public readonly string $topic,
+        public readonly string $address,
+        public readonly ?string $format = 'json'
+    ) {}
+}
diff --git a/src/Application/System/BootLogger.php b/src/Application/System/BootLogger.php
new file mode 100644
index 00000000..6c47bfa5
--- /dev/null
+++ b/src/Application/System/BootLogger.php
@@ -0,0 +1,28 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Application\System;
+
+use App\Framework\Core\Events\ApplicationBooted;
+use App\Framework\Core\Events\OnEvent;
+use App\Framework\Logging\DefaultLogger;
+
+final readonly class BootLogger
+{
+    public function __construct(
+        private DefaultLogger $logger
+    ) {}
+
+    #[OnEvent]
+    public function log(ApplicationBooted $event): void
+    {
+        #echo "[Boot] {$event->bootTime->format('H:i:s')} | Env: {$event->environment}\n";
+
+        $this->logger->info('Application booted', [
+            'boot_time' => $event->bootTime->format('Y-m-d H:i:s.u'),
+            'environment' => $event->environment,
+            'memory_usage' => memory_get_usage(true),
+            'peak_memory' => memory_get_peak_usage(true)
+        ]);
+    }
+}
diff --git a/src/Application/System/ErrorLogger.php b/src/Application/System/ErrorLogger.php
new file mode 100644
index 00000000..1e175031
--- /dev/null
+++ b/src/Application/System/ErrorLogger.php
@@ -0,0 +1,24 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Application\System;
+
+use App\Framework\Core\Events\ErrorOccurred;
+use App\Framework\Core\Events\OnEvent;
+
+final readonly class ErrorLogger
+{
+    /**
+     * Logger für aufgetretene Fehler
+     */
+    #[OnEvent(priority: 10)]
+    public function logError(ErrorOccurred $event): void
+    {
+        $time = $event->occurredAt->format('Y-m-d H:i:s');
+        $requestId = $event->requestId ? "[Request: {$event->requestId}]" : '';
+        $message = "[{$time}] ERROR {$requestId} {$event->context}: {$event->error->getMessage()}";
+
+        // In einer produktiven Umgebung würden wir hier in eine Datei oder einen Service loggen
+        error_log($message);
+    }
+}
diff --git a/src/Application/System/UserRegistrationLogger.php b/src/Application/System/UserRegistrationLogger.php
new file mode 100644
index 00000000..a294e295
--- /dev/null
+++ b/src/Application/System/UserRegistrationLogger.php
@@ -0,0 +1,30 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Application\System;
+
+use App\Framework\Core\Events\OnEvent;
+use App\Framework\Core\Events\UserRegistered;
+
+/**
+ * Logger für Benutzerregistrierungen
+ */
+final readonly class UserRegistrationLogger
+{
+    /**
+     * Protokolliert die Registrierung eines neuen Benutzers
+     */
+    #[OnEvent]
+    public function logUserRegistration(UserRegistered $event): void
+    {
+        $message = sprintf(
+            "[%s] Neuer Benutzer registriert: %s (%s)",
+            $event->occurredAt->format('Y-m-d H:i:s'),
+            $event->username,
+            $event->email
+        );
+
+        // In der Produktion würden wir in eine Datei oder einen Service loggen
+        error_log($message);
+    }
+}
diff --git a/src/Application/Website/DemoQuery.php b/src/Application/Website/DemoQuery.php
new file mode 100644
index 00000000..8be2f698
--- /dev/null
+++ b/src/Application/Website/DemoQuery.php
@@ -0,0 +1,9 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Application\Website;
+
+final class DemoQuery
+{
+
+}
diff --git a/src/Application/Website/DemoQueryHandler.php b/src/Application/Website/DemoQueryHandler.php
new file mode 100644
index 00000000..c17e5d5a
--- /dev/null
+++ b/src/Application/Website/DemoQueryHandler.php
@@ -0,0 +1,15 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Application\Website;
+
+use App\Framework\QueryBus\QueryHandler;
+
+final class DemoQueryHandler
+{
+    #[QueryHandler]
+    public function handle(DemoQuery $query): DemoQueryReturn
+    {
+        return new DemoQueryReturn();
+    }
+}
diff --git a/src/Application/Website/DemoQueryReturn.php b/src/Application/Website/DemoQueryReturn.php
new file mode 100644
index 00000000..d13725c3
--- /dev/null
+++ b/src/Application/Website/DemoQueryReturn.php
@@ -0,0 +1,11 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Application\Website;
+
+final readonly class DemoQueryReturn
+{
+    public function __construct(
+        public string $test = 'Hallo Welt'
+    ) {}
+}
diff --git a/src/Application/Website/HomeRequest.php b/src/Application/Website/HomeRequest.php
new file mode 100644
index 00000000..7b01b8ee
--- /dev/null
+++ b/src/Application/Website/HomeRequest.php
@@ -0,0 +1,11 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Application\Website;
+
+use App\Framework\Http\ControllerRequest;
+
+final class HomeRequest implements ControllerRequest
+{
+    public string $test = 'hallo welt';
+}
diff --git a/src/Application/Website/HomeViewModel.php b/src/Application/Website/HomeViewModel.php
new file mode 100644
index 00000000..50dc35a6
--- /dev/null
+++ b/src/Application/Website/HomeViewModel.php
@@ -0,0 +1,18 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Application\Website;
+
+use App\Framework\Core\ViewModel;
+use App\Framework\View\Template;
+
+#[Template('test')]
+final class HomeViewModel implements ViewModel
+{
+    public function __construct(
+        public string $title,
+    )
+    {
+
+    }
+}
diff --git a/src/Application/Website/ShowHome.php b/src/Application/Website/ShowHome.php
index 26f8f512..7ae40531 100644
--- a/src/Application/Website/ShowHome.php
+++ b/src/Application/Website/ShowHome.php
@@ -4,30 +4,258 @@ declare(strict_types=1);
 
 namespace App\Application\Website;
 
+use App\Application\Service\QrCodeService;
+use App\Domain\AI\AiModel;
+use App\Domain\Media\ImageRepository;
+use App\Domain\Media\ImageSlot;
 use App\Framework\Attributes\Route;
+use App\Framework\Cache\Cache;
+use App\Framework\Core\PathProvider;
+use App\Framework\Database\ConnectionInterface;
+use App\Framework\Database\EntityManager;
+use App\Framework\DateTime\Clock;
+use App\Framework\DateTime\DateTimeFormatter;
+use App\Framework\DI\DefaultContainer;
+use App\Framework\Exception\FrameworkException;
+use App\Framework\Http\IpAddress;
 use App\Framework\Http\Request;
-use App\Framework\Router\ActionResult;
-use App\Framework\Router\ResultType;
+use App\Framework\Http\Session\Session;
+use App\Framework\HttpClient\CurlHttpClient;
+use App\Framework\Markdown\MarkdownConverter;
+use App\Framework\Meta\Keywords;
+use App\Framework\Meta\MetaData;
+use App\Framework\Meta\StaticPageMetaResolver;
+use App\Framework\QueryBus\QueryBus;
+use App\Framework\Router\Result\ViewResult;
+use App\Framework\Router\UrlGenerator;
+use App\Framework\SyntaxHighlighter\FileHighlighter;
+use App\Framework\SyntaxHighlighter\SyntaxHighlighter;
+use App\Framework\View\Engine;
+use App\Framework\View\RenderContext;
+use App\Framework\View\TemplateRenderer;
+use App\Infrastructure\AI\AiHandlerFactory;
+use App\Infrastructure\AI\AiService;
+use App\Infrastructure\GeoIp\DatabaseSetup;
+use App\Infrastructure\GeoIp\GeoIp;
+use SplFileObject;
 
-class ShowHome
+final readonly class ShowHome
 {
-    #[Route(method: 'GET', path: '/')]
-    public function __invoke(): ActionResult
+    public function __construct(
+        private QueryBus            $queryBus,
+        private DefaultContainer    $container,
+        private Clock               $clock,
+        private DateTimeFormatter   $dateTimeFormatter,
+        private EntityManager       $entityManager,
+        private Cache               $cache,
+        private ConnectionInterface $connection,
+        private PathProvider        $pathProvider,
+        private Session             $session,
+        private UrlGenerator        $urlGenerator,
+        private ImageRepository             $imageRepository,
+    ) {}
+
+    #[Route(path: '/', name: 'home')]
+    public function home(HomeRequest $request, string $test = 'hallo'): ViewResult
     {
-        return new ActionResult(
-            ResultType::Html,
-            'test',
-            ['name' => 'Michael','title' => 'HalloWeltTitel'],
+        #$imageSlot = $this->entityManager->findOneBy(ImageSlot::class, ['slot_name' => 'slot1']);
+
+        /*$image = $this->imageRepository->findBySlotName('slot1');
+
+        $filepath = $image->filename;
+
+        echo "<img src='/images/{$filepath}'  alt='AltText' style='width: 400px; object-fit: cover; aspect-ratio: 1; border-radius: 10px;'/>";*/
+
+
+        $model = new HomeViewModel('Hallo Welt!');
+
+        #$image = $this->imageRepository->findById("06BV7BSMPRX9ADY7XAQ5EC55YW");
+
+        #$filepath = "images/" . $image->filename;
+
+        #echo "<img src='{$filepath}'  alt='AltText'/>";
+
+        /*var_dump(sys_getloadavg());
+
+        # Beginn
+        $cpu_count = 1;
+        if(is_file('/proc/cpuinfo')) {
+            $cpuinfo = file_get_contents('/proc/cpuinfo');
+            preg_match_all('/^processor/m', $cpuinfo, $matches);
+            $cpu_count = count($matches[0]);
+        }
+
+        $sys_getloadavg = sys_getloadavg();
+        $sys_getloadavg[0] = $sys_getloadavg[0] / $cpu_count;
+        $sys_getloadavg[1] = $sys_getloadavg[1] / $cpu_count;
+        $sys_getloadavg[2] = $sys_getloadavg[2] / $cpu_count;
+
+        var_dump("<pre>", $sys_getloadavg);
+
+        $cpuinfo = file_get_contents('/proc/cpuinfo');
+
+        #var_dump("<pre>", $cpuinfo);*/
+
+
+
+        $highlighter = new SyntaxHighlighter();
+
+        $code = '<?php
+
+# Some Demo Function
+ function test(string $value): string
+ {
+    $result = $value;
+    return $result;
+ }
+ ?>';
+
+        #$code = file_get_contents(__DIR__ . '/ShowHome.php');
+
+        #echo new FileHighlighter()(__DIR__ . '/ShowHome.php', 48, 20);
+
+        // Einmalige Initialisierung
+        #$setup = new DatabaseSetup(__DIR__ . '/Infrastructure/GeoIp/data/ip_country.sqlite');
+        #$setup->setupCompleteDatabase();
+
+        // Normale Verwendung
+        $geoIp = new GeoIp(__DIR__ . '/Infrastructure/GeoIp/data/ip_country.sqlite');
+        $countryInfo = $geoIp->getCountryInfo('83.135.161.55');
+
+        /*echo 'Code: ' . $countryInfo->countryCode . "\n";
+        echo 'Deutsch: ' . $countryInfo->getGermanName() . "\n";
+        echo 'English: ' . $countryInfo->getEnglishName() . "\n";
+
+        var_dump($countryInfo);*/
+
+
+
+        $model = new HomeViewModel('Hallo Welt!');
+
+        $aiService = new AiService(new AiHandlerFactory(new CurlHttpClient()));
+
+
+
+
+       /* $status = opcache_get_status(true);
+        unset($status['scripts']);
+
+
+        $response = $aiService->query('Bitte visualisiere mir den OPCache Status kompakt: '.print_r($status, true), AiModel::OLLAMA_QWEN2_5);
+
+        $response = $aiService->query('Du wirst in meinem PHP Framework ausgeführt. Kann ich dir Frameworkdaten irgendwie zugänglich machen?', AiModel::OLLAMA_QWEN2_5, messages: [
+            ['role' => 'system', 'content' => 'Du bist ein hilfreicher Programmier-Assistent.'],
+            ['role' => 'user', 'content' => 'Du wirst in meinem PHP Framework ausgeführt. Kann ich dir Frameworkdaten irgendwie zugänglich machen?'],
+            ['role' => 'user', 'content' => ''],
+            ]);
+
+        $html = new MarkdownConverter()->toHtml($response->content);
+
+        echo $html;*/
+
+
+
+        if($this->session->validation->has('form', 'consent')) {
+
+            #debug($this->session->form->get('form'));
+
+
+            #debug($this->session->validation->getField('form', 'consent'));
+
+            $this->session->validation->clearAll();
+        }
+
+
+        // Cache löschen für frische Ergebnisse
+        #$this->cache->forget('unified_discovery_results');
+        #$this->cache->forget('attribute_discovery');
+
+
+        #var_dump("<pre>");
+
+        // Debug-Ausgaben hinzufügen
+        #var_dump('Discovery Results:' , $results->toArray());
+        #var_dump('All Attribute Results:', $results->getAllAttributeResults());
+        #var_dump('Processed File Count:', $discovery->getProcessedFileCount());
+
+// Teste ob ShowHome gefunden wird
+        $basePath = $this->pathProvider->getBasePath();
+        #debug('Scanning path:', $basePath . '/src');
+
+
+
+        /*
+         *  [Field] => id
+            [Type] => int(11)
+            [Null] => NO
+            [Key] => PRI
+            [Default] =>
+            [Extra] =>
+         */
+
+        /*$tables = $this->connection->query('SHOW FULL TABLES;')->fetchAll();
+        $columns = $this->connection->query('SHOW COLUMNS FROM users;')->fetchAll();
+        $table = "<h2>Table: test</h2><table><tr><th>Field</th><th>Type</th><th>Null</th><th>Key</th><th>Default</th></tr>";
+
+        foreach ($columns as $column) {
+            $table .= sprintf("<tr> <td>%s</td> <td>%s</td> <td>%s</td> <td>%s</td> <td>%s</td></tr>", $column['Field'], $column['Type'], $column['Null'], $column['Key'], $column['Default']);
+        }
+        $table .= "</table>";
+
+        echo $table;
+
+
+        dd($columns);*/
+
+
+
+        $result = $this->queryBus->dispatch(new DemoQuery());
+
+        #echo $result->test;
+
+        $httpRequest = $this->container->get(Request::class);
+
+        $protocol = $httpRequest->server->getHttpHost();
+
+
+        #debug($this->entityManager->find(User::class, 1)->name, 'User');
+
+        #$qrCodeService = new QrCodeService(new QrCodeGenerator(new QrCodeEncoder(), new QrCodeRenderer()));
+
+        #$code = $qrCodeService->generateQrCode('Michael Schiemer');
+
+        #echo $code->toSvg();
+
+
+        #var_dump($this->dateTimeFormatter->formatTime($this->clock->now()));
+
+
+        return new ViewResult(
+            template: 'xtest',
+            metaData: new StaticPageMetaResolver(
+                title: 'Home',
+                description: 'Hallo Welt!',
+            )(),
+            data: ['name' => 'Michael'],
+            model: $model,
         );
     }
 
-    #[Route(method: 'GET', path: '/epk')]
-    public function impressum(string $test = 'hallo'): ActionResult
+    #[Route(path: '/epk')]
+    public function epk(string $test = 'hallo'): ViewResult
     {
-        return new ActionResult(
-            ResultType::Plain,
+        return new ViewResult(
             'test',
-            ['text' => 'EPK!'],
+            new MetaData('EPK'),
+        );
+    }
+
+    #[Route(path: '/designsystem')]
+    public function designSystem(): ViewResult
+    {
+        return new ViewResult(
+            'designsystem',
+            new MetaData('DesignSystem')
         );
     }
 }
diff --git a/src/Application/Website/ShowImpressum.php b/src/Application/Website/ShowImpressum.php
index 1fa8aef7..17ec6386 100644
--- a/src/Application/Website/ShowImpressum.php
+++ b/src/Application/Website/ShowImpressum.php
@@ -4,28 +4,129 @@ declare(strict_types=1);
 
 namespace App\Application\Website;
 
+use App\Domain\Media\ImageProcessor;
+use App\Domain\Media\ImageRepository;
+use App\Domain\Media\ImageSourceSetGenerator;
+use App\Domain\Media\ImageVariantRepository;
 use App\Framework\Attributes\Route;
+use App\Framework\Attributes\StaticPage;
+use App\Framework\Http\Method;
+use App\Framework\Meta\Keywords;
+use App\Framework\Meta\StaticPageMetaResolver;
 use App\Framework\Router\ActionResult;
-use App\Framework\Router\ResultType;
+use App\Framework\Router\Result\Redirect;
+use App\Framework\Router\Result\ViewResult;
+use FilesystemIterator;
+use RecursiveDirectoryIterator;
+use RecursiveIteratorIterator;
 
-class ShowImpressum
+final readonly class ShowImpressum
 {
-    #[Route(method: 'GET', path: '/impressum')]
-    public function impressum(string $test = 'hallo'): ActionResult
+    public function __construct(
+        private ImageRepository $imageRepository,
+        private ImageProcessor $imageProcessor,
+        private ImageVariantRepository $imageVariantRepository,
+    )
     {
-        return new ActionResult(
-            ResultType::Html,
+    }
+
+
+    #[StaticPage]
+    #[Route(path: '/impressum', name: 'impressum')]
+    public function impressum(): ViewResult
+    {
+        /*$sg = new ImageSourceSetGenerator();
+
+        $images = $this->imageRepository->findAll();
+
+        foreach($images as $image) {
+            echo $sg->generatePictureElement($image);
+        }*/
+
+
+        // Cleanup Media Files that are not saved to Database
+
+        $path = '/var/www/html/storage/uploads/2025';
+
+        $rii = new \RecursiveIteratorIterator(new \RecursiveDirectoryIterator($path, FilesystemIterator::SKIP_DOTS));
+
+        /** @var \SplFileInfo $file */
+        foreach($rii as $file) {
+
+            $variant = $this->imageVariantRepository->findByFilename($file->getFilename());
+
+            if($variant === null) {
+                $image = $this->imageRepository->findByFilename($file->getFilename());
+                if($image === null) {
+                    $success = unlink($file->getPathname());
+                    #var_dump($success);
+                }
+            }
+        }
+
+        // Delete empty Folders.
+
+        $emptyDirs = [];
+
+        $iterator = new RecursiveIteratorIterator(
+            new RecursiveDirectoryIterator($path, FilesystemIterator::SKIP_DOTS),
+            RecursiveIteratorIterator::CHILD_FIRST // Ordner erst nach dem Inhalt prüfen
+        );
+
+        foreach ($iterator as $fileInfo) {
+            if ($fileInfo->isDir()) {
+                // Verzeichnis öffnen und prüfen, ob es leer ist
+                $files = array_diff(scandir($fileInfo->getPathname()), ['.', '..']);
+                if (empty($files)) {
+                    $emptyDirs[] = $fileInfo->getPathname();
+                    rmdir($fileInfo->getPathname());
+                }
+            }
+        }
+        #var_dump($emptyDirs);
+
+
+
+
+
+
+        /*$images = $this->imageRepository->findAll();
+
+        foreach($images as $image) {
+            $path = ($image->path);
+            #chmod($path, 0755);
+            #var_dump(is_writable($path));
+            $variants = $this->imageProcessor->createAllVariants($image);
+
+            foreach($variants as $variant) {
+                try {
+                    $this->imageVariantRepository->save($variant);
+                } catch (\Throwable $th) {
+                    var_dump($variant);
+                    var_dump('already saved');
+                }
+            }
+        }*/
+
+        return new ViewResult(
             'impressum',
+            new StaticPageMetaResolver(
+                'Impressum',
+                'Hallo Welt!',
+            )(),
             ['text' => 'Hallo Welt!'],
         );
     }
 
-    #[Route(method: 'GET', path: '/datenschutz')]
-    public function datenschutz(string $test = 'hallo'): ActionResult
+    #[Route(path: '/datenschutz', name: 'datenschutz')]
+    public function datenschutz(): ViewResult
     {
-        return new ActionResult(
-            ResultType::Html,
+        return new ViewResult(
             'impressum',
+            new StaticPageMetaResolver(
+                'Datenschutz',
+                'Hallo Welt!',
+            )(),
             ['title' => 'Datenschutz!'],
         );
     }
diff --git a/src/Application/Website/ShowSitemap.php b/src/Application/Website/ShowSitemap.php
new file mode 100644
index 00000000..08a19e27
--- /dev/null
+++ b/src/Application/Website/ShowSitemap.php
@@ -0,0 +1,52 @@
+<?php
+
+namespace App\Application\Website;
+
+use App\Framework\Attributes\Route;
+use App\Framework\Discovery\Results\DiscoveryResults;
+use App\Framework\Http\Headers;
+use App\Framework\Http\HttpResponse;
+use App\Framework\Meta\StaticPageMetaResolver;
+use App\Framework\Router\HttpRouter;
+use App\Framework\Router\Result\ViewResult;
+use App\Framework\Sitemap\SitemapGenerator;
+
+final readonly class ShowSitemap
+{
+    public function __construct(
+        private SitemapGenerator $sitemapGenerator,
+    ) {}
+
+    private function generateSitemapXml():string
+    {
+        $xml = '<?xml version="1.0" encoding="UTF-8"?>' . "\n";
+        $xml .= '<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">' . "\n";
+
+        foreach ($this->sitemapGenerator->generateFromRoutes() as $entry) {
+            $xml .= '  ' . $entry->toXml() . "\n";
+        }
+
+        $xml .= '</urlset>';
+        return $xml;
+    }
+
+    #[Route(path: '/sitemap.xml', name: 'sitemap')]
+    public function __invoke(): HttpResponse
+    {
+        $xml = $this->generateSitemapXml();
+
+        return new HttpResponse(
+            headers: new Headers(['Content-Type' => 'application/xml']),
+            body   : $xml
+        );
+
+        #https://www.flowmatters.com/blog/how-to-improve-your-seo-by-optimising-a-dynamic-sitemap-xml-gz-using-php/
+    }
+
+    #[Route(path: '/sitemap', name: 'sitemap_readable')]
+    public function sitemap():ViewResult
+    {
+        return new ViewResult('sitemap',
+        new StaticPageMetaResolver('Sitemap', 'Die Sitemap')());
+    }
+}
diff --git a/src/Application/Website/ShowVcard.php b/src/Application/Website/ShowVcard.php
new file mode 100644
index 00000000..95255725
--- /dev/null
+++ b/src/Application/Website/ShowVcard.php
@@ -0,0 +1,36 @@
+<?php
+
+namespace App\Application\Website;
+
+use App\Framework\Attributes\Route;
+use JetBrains\PhpStorm\NoReturn;
+
+final readonly class ShowVcard
+{
+    #[NoReturn] #[Route('/kontakt.vcf')]
+    public function __invoke(): void
+    {
+        // Kontaktdaten
+        $name = "Michael";
+        $nachname = "Schiemer";
+        $telefon = "+49 123 456789";
+        $email = "konakt@michaelschiemer.de";
+
+        // vCard-Text zusammenbauen
+        $vcf = "BEGIN:VCARD\r\n";
+        $vcf .= "VERSION:3.0\r\n";
+        $vcf .= "N:$nachname;$name;;;\r\n";
+        $vcf .= "FN:$name $nachname\r\n";
+        $vcf .= "TEL;TYPE=CELL,VOICE:$telefon\r\n";
+        $vcf .= "EMAIL;TYPE=INTERNET:$email\r\n";
+        $vcf .= "END:VCARD\r\n";
+
+        // Datei speichern
+
+        // Oder zum Download anbieten
+        header('Content-Type: text/vcard; charset=utf-8');
+        header('Content-Disposition: attachment; filename="kontakt.vcf"');
+        echo $vcf;
+        exit;
+    }
+}
diff --git a/src/Application/Website/templates/sitemap.view.php b/src/Application/Website/templates/sitemap.view.php
new file mode 100644
index 00000000..71e95762
--- /dev/null
+++ b/src/Application/Website/templates/sitemap.view.php
@@ -0,0 +1,3 @@
+<layout src="main" />
+
+<h2>Sitemap</h2>
diff --git a/src/Domain/AI/AiModel.php b/src/Domain/AI/AiModel.php
new file mode 100644
index 00000000..452c7895
--- /dev/null
+++ b/src/Domain/AI/AiModel.php
@@ -0,0 +1,63 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Domain\AI;
+
+enum AiModel: string
+{
+    // OpenAI Models
+    case GPT_35_TURBO = 'gpt-3.5-turbo';
+    case GPT_4 = 'gpt-4';
+    case GPT_4_TURBO = 'gpt-4-turbo';
+    case GPT_4O = 'gpt-4o';
+    case GPT_4O_MINI = 'gpt-4o-mini';
+
+    // GPT4All Models
+    case LLAMA2_7B = 'llama2-7b';
+    case MISTRAL_7B = 'mistral-7b-instruct';
+    case CODE_LLAMA_7B = 'codellama-7b-instruct';
+    case ORCA_MINI_3B = 'orca-mini-3b';
+    case VICUNA_7B = 'vicuna-7b';
+
+    // Ollama Models
+    case OLLAMA_LLAMA2 = 'llama2';
+    case OLLAMA_LLAMA2_13B = 'llama2:13b';
+    case OLLAMA_LLAMA2_70B = 'llama2:70b';
+    case OLLAMA_MISTRAL = 'mistral';
+    case OLLAMA_MISTRAL_7B = 'mistral:7b';
+    case OLLAMA_CODELLAMA = 'codellama';
+    case OLLAMA_CODELLAMA_13B = 'codellama:13b';
+    case OLLAMA_GEMMA = 'gemma';
+    case OLLAMA_GEMMA_7B = 'gemma:7b';
+    case OLLAMA_NEURAL_CHAT = 'neural-chat';
+    case OLLAMA_STARLING = 'starling-lm';
+    case OLLAMA_ORCA_MINI = 'orca-mini';
+    case OLLAMA_VICUNA = 'vicuna';
+    case OLLAMA_LLAMA3 = 'llama3';
+    case OLLAMA_LLAMA3_8B = 'llama3:8b';
+    case OLLAMA_LLAMA3_70B = 'llama3:70b';
+    case OLLAMA_PHI3 = 'phi3';
+    case OLLAMA_QWEN = 'qwen';
+
+    case OLLAMA_QWEN2_5 = 'qwen2.5:7b';
+    case OLLAMA_QWEN2_5_CODER = 'qwen2.5-coder:7b';
+    case OLLAMA_LLAMA3_1 = 'llama3.1:8b';
+    case OLLAMA_LLAMA3_2_3B = 'llama3.2:3b';
+    case OLLAMA_DEEPSEEK_CODER = 'deepseek-coder:6.7b';
+
+
+    public function getProvider(): AiProvider
+    {
+        return match($this) {
+            self::GPT_35_TURBO, self::GPT_4, self::GPT_4_TURBO, self::GPT_4O, self::GPT_4O_MINI => AiProvider::OPENAI,
+            self::LLAMA2_7B, self::MISTRAL_7B, self::CODE_LLAMA_7B, self::ORCA_MINI_3B, self::VICUNA_7B => AiProvider::GPT4ALL,
+            self::OLLAMA_LLAMA2, self::OLLAMA_LLAMA2_13B, self::OLLAMA_LLAMA2_70B,
+            self::OLLAMA_MISTRAL, self::OLLAMA_MISTRAL_7B, self::OLLAMA_CODELLAMA,
+            self::OLLAMA_CODELLAMA_13B, self::OLLAMA_GEMMA, self::OLLAMA_GEMMA_7B,
+            self::OLLAMA_NEURAL_CHAT, self::OLLAMA_STARLING, self::OLLAMA_ORCA_MINI,
+            self::OLLAMA_VICUNA, self::OLLAMA_LLAMA3, self::OLLAMA_LLAMA3_8B,
+            self::OLLAMA_LLAMA3_70B, self::OLLAMA_PHI3, self::OLLAMA_QWEN,
+            self::OLLAMA_QWEN2_5, self::OLLAMA_QWEN2_5_CODER, self::OLLAMA_LLAMA3_1, self::OLLAMA_LLAMA3_2_3B, self::OLLAMA_DEEPSEEK_CODER => AiProvider::OLLAMA,
+        };
+    }
+}
diff --git a/src/Domain/AI/AiProvider.php b/src/Domain/AI/AiProvider.php
new file mode 100644
index 00000000..3bc53999
--- /dev/null
+++ b/src/Domain/AI/AiProvider.php
@@ -0,0 +1,11 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Domain\AI;
+
+enum AiProvider: string
+{
+    case OPENAI = 'openai';
+    case GPT4ALL = 'gpt4all';
+    case OLLAMA = 'ollama';
+}
diff --git a/src/Domain/AI/AiQuery.php b/src/Domain/AI/AiQuery.php
new file mode 100644
index 00000000..a2b23ea0
--- /dev/null
+++ b/src/Domain/AI/AiQuery.php
@@ -0,0 +1,15 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Domain\AI;
+
+final class AiQuery
+{
+    public function __construct(
+        public string $message,
+        public AiModel $model,
+        public array $messages = [],
+        public float $temperature = 0.7,
+        public ?int $maxTokens = null
+    ) {}
+}
diff --git a/src/Domain/AI/AiQueryHandlerInterface.php b/src/Domain/AI/AiQueryHandlerInterface.php
new file mode 100644
index 00000000..28ca6878
--- /dev/null
+++ b/src/Domain/AI/AiQueryHandlerInterface.php
@@ -0,0 +1,9 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Domain\AI;
+
+interface AiQueryHandlerInterface
+{
+    public function __invoke(AiQuery $query): AiResponse;
+}
diff --git a/src/Domain/AI/AiResponse.php b/src/Domain/AI/AiResponse.php
new file mode 100644
index 00000000..35e52ba4
--- /dev/null
+++ b/src/Domain/AI/AiResponse.php
@@ -0,0 +1,14 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Domain\AI;
+
+final class AiResponse
+{
+    public function __construct(
+        public string $content,
+        public string $provider,
+        public string $model,
+        public ?int $tokensUsed = null
+    ) {}
+}
diff --git a/src/Domain/AI/Exception/AiProviderUnavailableException.php b/src/Domain/AI/Exception/AiProviderUnavailableException.php
new file mode 100644
index 00000000..de99fb5a
--- /dev/null
+++ b/src/Domain/AI/Exception/AiProviderUnavailableException.php
@@ -0,0 +1,19 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Domain\AI\Exception;
+
+use App\Framework\Exception\FrameworkException;
+use App\Domain\AI\AiProvider;
+
+class AiProviderUnavailableException extends FrameworkException
+{
+    public function __construct(AiProvider $provider, string $reason = '')
+    {
+        $message = "AI Provider '{$provider->value}' ist nicht verfügbar";
+        if ($reason) {
+            $message .= ": $reason";
+        }
+        parent::__construct($message);
+    }
+}
diff --git a/src/Domain/AI/Role.php b/src/Domain/AI/Role.php
new file mode 100644
index 00000000..1bd88919
--- /dev/null
+++ b/src/Domain/AI/Role.php
@@ -0,0 +1,11 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Domain\AI;
+
+enum Role:string
+{
+    case SYSTEM = 'system';
+    case USER = 'user';
+    case ASSISTANT = 'assistant';
+}
diff --git a/src/Domain/Common/ValueObject/Email.php b/src/Domain/Common/ValueObject/Email.php
new file mode 100644
index 00000000..2effef7c
--- /dev/null
+++ b/src/Domain/Common/ValueObject/Email.php
@@ -0,0 +1,39 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Domain\Common\ValueObject;
+
+final readonly class Email
+{
+    /**
+     * @param string $value Email-Adresse
+     */
+    public function __construct(
+        public string $value
+    ) {
+        if (empty($value)) {
+            throw new \InvalidArgumentException('E-Mail-Adresse darf nicht leer sein.');
+        }
+
+        if (!filter_var($value, FILTER_VALIDATE_EMAIL)) {
+            throw new \InvalidArgumentException('Ungültige E-Mail-Adresse: ' . $value);
+        }
+
+        // Optional: Einfache Domain-Prüfung ohne externen Aufruf
+        $domain = substr(strrchr($value, '@'), 1);
+        if (strlen($domain) < 4 || !str_contains($domain, '.')) {
+            throw new \InvalidArgumentException('Ungültige Domain in der E-Mail-Adresse: ' . $domain);
+        }
+
+    }
+
+    public function equals(self $other): bool
+    {
+        return $this->value === $other->value;
+    }
+
+    public function __toString(): string
+    {
+        return $this->value;
+    }
+}
diff --git a/src/Domain/Common/ValueObject/RGBColor.php b/src/Domain/Common/ValueObject/RGBColor.php
new file mode 100644
index 00000000..ccf0a689
--- /dev/null
+++ b/src/Domain/Common/ValueObject/RGBColor.php
@@ -0,0 +1,47 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Domain\Common\ValueObject;
+
+final readonly class RGBColor
+{
+    private function __construct(
+        public int $red,
+        public int $green,
+        public int $blue
+    ) {
+        foreach([$red, $green, $blue,
+        ] as $value) {
+            if ($value < 0 || $value > 255) {
+                throw new \InvalidArgumentException(
+                    sprintf(
+                        'RGB-Farbwert (%d, %d, %d) muss zwischen 0 und 255 liegen.',
+                        $red, $green, $blue
+                    ));
+            }
+        }
+    }
+
+    public static function fromHex(string $hex): self
+    {
+        $red = hexdec(substr($hex, 0, 2));
+        $green = hexdec(substr($hex, 2, 2));
+        $blue = hexdec(substr($hex, 4, 2));
+        return new self($red, $green, $blue);
+    }
+
+    public static function fromRgb(int $red, int $green, int $blue): self
+    {
+        return new self($red, $green, $blue);
+    }
+
+    public function toHex(): string
+    {
+        return sprintf('#%02x%02x%02x', $this->red, $this->green, $this->blue);
+    }
+
+    public function toRgb(): string
+    {
+        return sprintf('rgb(%d, %d, %d)', $this->red, $this->green, $this->blue);
+    }
+}
diff --git a/src/Domain/Contact/ContactMessage.php b/src/Domain/Contact/ContactMessage.php
new file mode 100644
index 00000000..c0bdc1e1
--- /dev/null
+++ b/src/Domain/Contact/ContactMessage.php
@@ -0,0 +1,18 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Domain\Contact;
+
+use App\Framework\Database\Attributes\Entity;
+
+#[Entity(tableName: 'contacts')]
+final readonly class ContactMessage
+{
+    public function __construct(
+        public string $name,
+
+        public string $email,
+
+        public string $message,
+    ){}
+}
diff --git a/src/Domain/Contact/ContactRepository.php b/src/Domain/Contact/ContactRepository.php
new file mode 100644
index 00000000..05effb1a
--- /dev/null
+++ b/src/Domain/Contact/ContactRepository.php
@@ -0,0 +1,18 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Domain\Contact;
+
+use App\Framework\Database\EntityManager;
+
+final readonly class ContactRepository
+{
+    public function __construct(
+        private EntityManager $entityManager
+    ) {}
+
+    public function save(ContactMessage $contact): void
+    {
+        $this->entityManager->save($contact);
+    }
+}
diff --git a/src/Domain/Contact/Migrations/CreateContactTable.php b/src/Domain/Contact/Migrations/CreateContactTable.php
new file mode 100644
index 00000000..eba88a24
--- /dev/null
+++ b/src/Domain/Contact/Migrations/CreateContactTable.php
@@ -0,0 +1,38 @@
+<?php
+
+namespace App\Domain\Contact\Migrations;
+
+use App\Framework\Database\ConnectionInterface;
+use App\Framework\Database\Migration\Migration;
+
+final readonly class CreateContactTable implements Migration
+{
+
+    public function up(ConnectionInterface $connection): void
+    {
+        $sql = <<<SQL
+        CREATE TABLE IF NOT EXISTS contacts (
+            id INT AUTO_INCREMENT PRIMARY KEY,
+            name VARCHAR(255) NOT NULL,
+            email VARCHAR(255) NOT NULL,
+            message TEXT NOT NULL
+        )
+SQL;
+        $connection->execute($sql);
+    }
+
+    public function down(ConnectionInterface $connection): void
+    {
+        $connection->execute('DROP TABLE IF EXISTS contacts');
+    }
+
+    public function getVersion(): string
+    {
+        return '005';
+    }
+
+    public function getDescription(): string
+    {
+        return 'Create contact table';
+    }
+}
diff --git a/src/Domain/Media/GdImageProcessor.php b/src/Domain/Media/GdImageProcessor.php
new file mode 100644
index 00000000..223f3f35
--- /dev/null
+++ b/src/Domain/Media/GdImageProcessor.php
@@ -0,0 +1,216 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Domain\Media;
+
+/**
+ * GD-basierter Bildprozessor als Fallback
+ */
+final readonly class GdImageProcessor implements ImageProcessorInterface
+{
+    /**
+     * @inheritDoc
+     */
+    public function createAllVariants(Image $image): array
+    {
+        $variants = [];
+
+        foreach (ImageVariantConfig::getAllVariants() as $variantConfig) {
+            try {
+                $variant = $this->createVariant($image, $variantConfig);
+                $variants[] = $variant;
+            } catch (\Exception $e) {
+                error_log("Failed to create variant {$variantConfig['type']->value}_{$variantConfig['size']->value}_{$variantConfig['format']->value}: " . $e->getMessage());
+            }
+        }
+
+        return $variants;
+    }
+
+    /**
+     * @inheritDoc
+     */
+    public function createVariantsForType(Image $image, ImageVariantType $type): array
+    {
+        $variants = [];
+
+        foreach (ImageVariantConfig::getVariantsForType($type) as $variantConfig) {
+            try {
+                $variant = $this->createVariant($image, $variantConfig);
+                $variants[] = $variant;
+            } catch (\Exception $e) {
+                error_log("Failed to create variant {$variantConfig['type']->value}_{$variantConfig['size']->value}_{$variantConfig['format']->value}: " . $e->getMessage());
+            }
+        }
+
+        return $variants;
+    }
+
+    /**
+     * Erstellt eine einzelne Bildvariante
+     *
+     * @param Image $image
+     * @param array $config
+     * @return ImageVariant
+     */
+    private function createVariant(Image $image, array $config): ImageVariant
+    {
+        $sourcePath = $image->path . $image->filename;
+
+        /** @var ImageVariantType $type */
+        /** @var ImageSize $size */
+        /** @var ImageFormat $format */
+        $type = $config['type'];
+        $size = $config['size'];
+        $format = $config['format'];
+        $width = $config['width'];
+
+        $filename = $this->generateVariantFilename(
+            $image->filename,
+            $type->value,
+            $size->value,
+            $format->value
+        );
+
+        $destination = $image->path . $filename;
+
+        $actualDimensions = $this->processImage($sourcePath, $destination, $width, $format);
+
+        $fileSize = filesize($destination);
+
+        return new ImageVariant(
+            imageId: $image->ulid,
+            variantType: $type->value,
+            size: $size->value,
+            format: $format->value,
+            mimeType: $format->getMimeType(),
+            fileSize: $fileSize,
+            width: $actualDimensions['width'],
+            height: $actualDimensions['height'],
+            filename: $filename,
+            path: $image->path,
+        );
+    }
+
+    /**
+     * Generiert einen Dateinamen für eine Bildvariante
+     */
+    private function generateVariantFilename(string $originalFilename, string $type, string $size, string $format): string
+    {
+        $pathInfo = pathinfo($originalFilename);
+        return $pathInfo['filename'] . "_{$type}_{$size}.{$format}";
+    }
+
+    /**
+     * Verarbeitet das Bild mit GD
+     *
+     * @param string $sourcePath
+     * @param string $destination
+     * @param int $maxWidth
+     * @param ImageFormat $format
+     * @return array{width: int, height: int}
+     */
+    private function processImage(string $sourcePath, string $destination, int $maxWidth, ImageFormat $format): array
+    {
+        $imageInfo = getimagesize($sourcePath);
+        if ($imageInfo === false) {
+            throw new \RuntimeException('Could not get image info');
+        }
+
+        $source = $this->createImageFromFile($sourcePath, $imageInfo[2]);
+
+        $originalWidth = imagesx($source);
+        $originalHeight = imagesy($source);
+
+        // Nur die Breite begrenzen, Höhe proportional berechnen
+        $scale = $maxWidth / $originalWidth;
+
+        // Nur skalieren wenn nötig
+        if ($originalWidth > $maxWidth) {
+            $newWidth = $maxWidth;
+            $newHeight = (int)round($originalHeight * $scale);
+        } else {
+            $newWidth = $originalWidth;
+            $newHeight = $originalHeight;
+            // Kopie für konsistente Verarbeitung
+            $dst = imagecreatetruecolor($newWidth, $newHeight);
+            imagecopy($dst, $source, 0, 0, 0, 0, $newWidth, $newHeight);
+            imagedestroy($source);
+            $this->saveImageInFormat($dst, $destination, $format);
+            imagedestroy($dst);
+            return ['width' => $newWidth, 'height' => $newHeight];
+        }
+
+        $dst = imagecreatetruecolor($newWidth, $newHeight);
+
+        // Transparenz erhalten
+        if ($format === ImageFormat::WEBP || $imageInfo[2] === IMAGETYPE_PNG) {
+            imagealphablending($dst, false);
+            imagesavealpha($dst, true);
+            $transparent = imagecolorallocatealpha($dst, 0, 0, 0, 127);
+            imagefilledrectangle($dst, 0, 0, $newWidth, $newHeight, $transparent);
+        }
+
+        // Bessere Qualität mit IMAGICK_FILTER_LANCZOS Equivalent
+        imagecopyresampled($dst, $source, 0, 0, 0, 0, $newWidth, $newHeight, $originalWidth, $originalHeight);
+
+        // Einfache Schärfung bei Verkleinerung
+        if ($scale < 0.8) {
+            $this->sharpenImage($dst);
+        }
+
+        $this->saveImageInFormat($dst, $destination, $format);
+
+        imagedestroy($source);
+        imagedestroy($dst);
+
+        return ['width' => $newWidth, 'height' => $newHeight];
+    }
+
+    /**
+     * Erstellt ein Bild aus einer Datei
+     */
+    private function createImageFromFile(string $sourcePath, int $imageType): \GdImage
+    {
+        return match ($imageType) {
+            IMAGETYPE_PNG => imagecreatefrompng($sourcePath),
+            IMAGETYPE_JPEG => imagecreatefromjpeg($sourcePath),
+            IMAGETYPE_GIF => imagecreatefromgif($sourcePath),
+            IMAGETYPE_WEBP => imagecreatefromwebp($sourcePath),
+            default => throw new \RuntimeException('Unsupported image type'),
+        };
+    }
+
+    /**
+     * Speichert ein Bild im angegebenen Format
+     */
+    private function saveImageInFormat(\GdImage $image, string $destination, ImageFormat $format): void
+    {
+        match ($format) {
+            ImageFormat::JPEG => imagejpeg($image, $destination, $format->getQuality()),
+            ImageFormat::WEBP => imagewebp($image, $destination, $format->getQuality()),
+            ImageFormat::AVIF => function_exists('imageavif')
+                ? imageavif($image, $destination, $format->getQuality())
+                : imagewebp($image, $destination, $format->getQuality()), // Fallback auf WebP
+        };
+    }
+
+    /**
+     * Einfache Schärfung mit Konvolution
+     */
+    private function sharpenImage(\GdImage $image): void
+    {
+        // Einfacher Sharpen-Kernel
+        $sharpenMatrix = [
+            [-1, -1, -1],
+            [-1, 16, -1],
+            [-1, -1, -1]
+        ];
+        $divisor = 8;
+        $offset = 0;
+
+        if (function_exists('imageconvolution')) {
+            imageconvolution($image, $sharpenMatrix, $divisor, $offset);
+        }
+    }
+}
diff --git a/src/Domain/Media/Image.php b/src/Domain/Media/Image.php
new file mode 100644
index 00000000..c31a6c64
--- /dev/null
+++ b/src/Domain/Media/Image.php
@@ -0,0 +1,41 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Domain\Media;
+
+use App\Framework\Database\Attributes\Column;
+use App\Framework\Database\Attributes\Entity;
+use App\Framework\Database\Attributes\Type;
+
+#[Entity(tableName: 'images', idColumn: 'ulid')]
+final readonly class Image
+{
+    /** @var ImageVariant[] $variants */
+    #[Type(ImageVariant::class, foreignKey: 'image_id', localKey: 'ulid')]
+    public array $variants;
+
+    public function __construct(
+        /*#[Column(name: 'id', primary: true)]
+        public int $id,*/
+        #[Column(name: 'ulid', primary: true)]
+        public string $ulid,
+        #[Column(name: 'filename')]
+        public string $filename,
+        #[Column(name: 'original_filename')]
+        public string $originalFilename,
+        #[Column(name: 'mime_type')]
+        public string $mimeType,
+        #[Column(name: 'file_size')]
+        public int    $fileSize,
+        #[Column(name: 'width')]
+        public int    $width,
+        #[Column(name: 'height')]
+        public int $height,
+        #[Column(name: 'hash'/*, unique: true*/)]
+        public string $hash,
+        #[Column(name: 'path')]
+        public string $path,
+        #[Column(name: 'alt_text')]
+        public string $altText,
+    ){}
+}
diff --git a/src/Domain/Media/ImageFormat.php b/src/Domain/Media/ImageFormat.php
new file mode 100644
index 00000000..c1d4e5a9
--- /dev/null
+++ b/src/Domain/Media/ImageFormat.php
@@ -0,0 +1,28 @@
+<?php
+
+namespace App\Domain\Media;
+
+enum ImageFormat: string
+{
+    case AVIF = 'avif';
+    case WEBP = 'webp';
+    case JPEG = 'jpeg';
+
+    public function getMimeType(): string
+    {
+        return match ($this) {
+            self::AVIF => 'image/avif',
+            self::WEBP => 'image/webp',
+            self::JPEG => 'image/jpeg',
+        };
+    }
+
+    public function getQuality(): int
+    {
+        return match ($this) {
+            self::AVIF => 80,
+            self::WEBP => 85,
+            self::JPEG => 85,
+        };
+    }
+}
diff --git a/src/Domain/Media/ImageGallery.php b/src/Domain/Media/ImageGallery.php
new file mode 100644
index 00000000..ab343767
--- /dev/null
+++ b/src/Domain/Media/ImageGallery.php
@@ -0,0 +1,11 @@
+<?php
+
+namespace App\Domain\Media;
+
+use App\Framework\Database\Attributes\Entity;
+
+#[Entity(tableName: 'image_galleries')]
+class ImageGallery
+{
+
+}
diff --git a/src/Domain/Media/ImageProcessor.php b/src/Domain/Media/ImageProcessor.php
new file mode 100644
index 00000000..0b2a2767
--- /dev/null
+++ b/src/Domain/Media/ImageProcessor.php
@@ -0,0 +1,41 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Domain\Media;
+
+/**
+ * Adapter-Klasse für Abwärtskompatibilität
+ * Delegiert an die konkrete Implementierung
+ */
+final readonly class ImageProcessor implements ImageProcessorInterface
+{
+    /**
+     * @var ImageProcessorInterface
+     */
+    private ImageProcessorInterface $processor;
+
+    /**
+     * Konstruktor mit automatischer Dependency-Injection
+     */
+    public function __construct(?ImageProcessorInterface $processor = null)
+    {
+        // Wenn kein Processor übergeben wurde, Factory verwenden
+        $this->processor = $processor ?? ImageProcessorFactory::create();
+    }
+
+    /**
+     * @inheritDoc
+     */
+    public function createAllVariants(Image $image): array
+    {
+        return $this->processor->createAllVariants($image);
+    }
+
+    /**
+     * @inheritDoc
+     */
+    public function createVariantsForType(Image $image, ImageVariantType $type): array
+    {
+        return $this->processor->createVariantsForType($image, $type);
+    }
+}
diff --git a/src/Domain/Media/ImageProcessorFactory.php b/src/Domain/Media/ImageProcessorFactory.php
new file mode 100644
index 00000000..992a5216
--- /dev/null
+++ b/src/Domain/Media/ImageProcessorFactory.php
@@ -0,0 +1,40 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Domain\Media;
+
+/**
+ * Factory-Klasse zum Erstellen des richtigen ImageProcessor
+ */
+final readonly class ImageProcessorFactory
+{
+    /**
+     * Erstellt den optimalen ImageProcessor je nach verfügbaren Extensions
+     *
+     * @return ImageProcessorInterface Die beste verfügbare Implementation
+     */
+    public static function create(): ImageProcessorInterface
+    {
+        // Prüfen ob ImageMagick verfügbar ist
+        if (extension_loaded('imagick') && class_exists('\Imagick')) {
+            try {
+                // Test ob ImageMagick funktioniert
+                $test = new \Imagick();
+                $test->clear();
+                return new ImagickImageProcessor();
+            } catch (\Exception $e) {
+                error_log('ImageMagick is installed but not working: ' . $e->getMessage());
+            }
+        }
+
+        // Fallback auf GD
+        if (extension_loaded('gd') && function_exists('imagecreatetruecolor')) {
+            return new GdImageProcessor();
+        }
+
+        throw new \RuntimeException(
+            'No image processing library available. ' .
+            'Please install and enable either the ImageMagick or GD PHP extension.'
+        );
+    }
+}
diff --git a/src/Domain/Media/ImageProcessorInterface.php b/src/Domain/Media/ImageProcessorInterface.php
new file mode 100644
index 00000000..c50ada60
--- /dev/null
+++ b/src/Domain/Media/ImageProcessorInterface.php
@@ -0,0 +1,24 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Domain\Media;
+
+interface ImageProcessorInterface
+{
+    /**
+     * Erstellt alle konfigurierten Bildvarianten für ein Bild
+     *
+     * @param Image $image
+     * @return array<ImageVariant>
+     */
+    public function createAllVariants(Image $image): array;
+
+    /**
+     * Erstellt alle Bildvarianten für einen bestimmten Typ
+     *
+     * @param Image $image
+     * @param ImageVariantType $type
+     * @return array<ImageVariant>
+     */
+    public function createVariantsForType(Image $image, ImageVariantType $type): array;
+}
diff --git a/src/Domain/Media/ImageRepository.php b/src/Domain/Media/ImageRepository.php
new file mode 100644
index 00000000..aa8be52d
--- /dev/null
+++ b/src/Domain/Media/ImageRepository.php
@@ -0,0 +1,50 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Domain\Media;
+
+use App\Framework\Database\ConnectionInterface;
+use App\Framework\Database\EntityManager;
+use App\Framework\Database\Transaction;
+
+final readonly class ImageRepository
+{
+    public function __construct(
+        private EntityManager $entityManager,
+        private ConnectionInterface $connection,
+    ) {}
+
+
+    public function save(Image $image, string $tempPath): void
+    {
+        new SaveImageFile()($image, $tempPath);
+
+        $this->entityManager->save($image);
+    }
+
+    public function findBySlotName(string $slotName): Image
+    {
+        return $this->entityManager->findOneBy(ImageSlot::class, ['slot_name' => $slotName])->image;
+    }
+
+
+    public function findById(string $id): ?Image
+    {
+        return $this->entityManager->find(Image::class, $id);
+    }
+
+    public function findByFilename(string $filename): ?Image
+    {
+        return $this->entityManager->findOneBy(Image::class, ['filename' => $filename]);
+    }
+
+    public function findByHash(string $hash): ?Image
+    {
+        return $this->entityManager->findOneBy(Image::class, ['hash' => $hash]);
+    }
+
+    public function findAll(): array
+    {
+        return $this->entityManager->findAll(Image::class);
+    }
+}
diff --git a/src/Domain/Media/ImageResizer.php b/src/Domain/Media/ImageResizer.php
new file mode 100644
index 00000000..0e041b36
--- /dev/null
+++ b/src/Domain/Media/ImageResizer.php
@@ -0,0 +1,95 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Domain\Media;
+
+use App\Framework\DateTime\SystemClock;
+use App\Framework\Ulid\StringConverter;
+use App\Framework\Ulid\Ulid;
+
+final readonly class ImageResizer
+{
+    public function __construct() {}
+
+    public function __invoke(
+        Image $image,
+        int $maxWidth,
+        int $maxHeight,
+        int $quality = 9
+    ): ImageVariant
+    {
+        $sourcePath = $image->path . $image->filename;
+
+        $filename = str_replace('original', 'thumbnail', $image->filename);
+
+        $destination = $image->path . $filename;
+
+        $imageInfo = getimagesize($sourcePath);
+
+        if($imageInfo === false) {
+            throw new \RuntimeException('Could not get image info');
+        }
+
+        $imageType = $imageInfo[2];
+
+        $source = $this->createImageFromFile($sourcePath, $imageType);
+
+        $orignalWidth = imagesx($source);
+        $orignalHeight = imagesy($source);
+
+        $scale = min($maxWidth / $orignalWidth, $maxHeight / $orignalHeight);
+
+        $newWidth = (int)round($orignalWidth * $scale);
+        $newHeight = (int)round($orignalHeight * $scale);
+
+        #$src = imagecreatefrompng($sourcePath);
+        $dst = imagecreatetruecolor($newWidth, $newHeight);
+
+        imagecopyresampled($dst, $source, 0, 0, 0, 0, $newWidth, $newHeight, $orignalWidth, $orignalHeight);
+
+        $this->saveImage($dst, $destination, $imageType, $quality);
+
+        imagedestroy($source);
+        imagedestroy($dst);
+
+        $fileSize = filesize($destination);
+
+        // ULID mit StringConverter in binäres Format konvertieren
+        $binaryImageId = $image->ulid;
+
+
+        return new ImageVariant(
+            imageId    : $binaryImageId,
+            variantType: 'thumbnail',
+            format     : '',
+            mimeType   : $image->mimeType,
+            fileSize   : $fileSize,
+            width      : $newWidth,
+            height     : $newHeight,
+            filename   : $filename,
+            path: $image->path,
+        );
+    }
+
+
+    private function createImageFromFile(string $sourcePath, mixed $imageType) {
+        return match ($imageType) {
+            IMAGETYPE_PNG => imagecreatefrompng($sourcePath),
+            IMAGETYPE_JPEG => imagecreatefromjpeg($sourcePath),
+            IMAGETYPE_GIF => imagecreatefromgif($sourcePath),
+            IMAGETYPE_WEBP => imagecreatefromwebp($sourcePath),
+            default => throw new \RuntimeException('Unsupported image type'),
+        };
+    }
+
+    private function saveImage($image, string $destination, int $imageType, int $quality): void
+    {
+        match ($imageType) {
+            IMAGETYPE_JPEG => imagejpeg($image, $destination, $quality),
+            IMAGETYPE_PNG => imagepng($image, $destination, (int)round(9 - ($quality * 9 / 100))),
+            IMAGETYPE_GIF => imagegif($image, $destination),
+            IMAGETYPE_WEBP => imagewebp($image, $destination, $quality),
+            default => throw new \RuntimeException('Unsupported image type'),
+        };
+    }
+}
diff --git a/src/Domain/Media/ImageSize.php b/src/Domain/Media/ImageSize.php
new file mode 100644
index 00000000..be5155e6
--- /dev/null
+++ b/src/Domain/Media/ImageSize.php
@@ -0,0 +1,40 @@
+<?php
+
+namespace App\Domain\Media;
+
+enum ImageSize: string
+{
+    case SMALL = 'small';
+    case MEDIUM = 'medium';
+    case LARGE = 'large';
+    case XLARGE = 'xlarge';
+
+    public function getWidth(ImageVariantType $type): int
+    {
+        return match ([$type, $this]) {
+            [ImageVariantType::THUMBNAIL, self::SMALL] => 150,
+            [ImageVariantType::THUMBNAIL, self::MEDIUM] => 300,
+
+            [ImageVariantType::GALLERY, self::SMALL] => 400,
+            [ImageVariantType::GALLERY, self::MEDIUM] => 800,
+            [ImageVariantType::GALLERY, self::LARGE] => 1200,
+
+            [ImageVariantType::HERO, self::SMALL] => 768,
+            [ImageVariantType::HERO, self::MEDIUM] => 1024,
+            [ImageVariantType::HERO, self::LARGE] => 1920,
+            [ImageVariantType::HERO, self::XLARGE] => 2560,
+
+            default => throw new \InvalidArgumentException("Invalid combination: {$type->value} - {$this->value}"),
+        };
+    }
+
+    public function getBreakpoint(): ?int
+    {
+        return match ($this) {
+            self::SMALL => 768,
+            self::MEDIUM => 1024,
+            self::LARGE => 1920,
+            self::XLARGE => null, // Keine Breakpoint-Beschränkung
+        };
+    }
+}
diff --git a/src/Domain/Media/ImageSlot.php b/src/Domain/Media/ImageSlot.php
new file mode 100644
index 00000000..cf5ea85e
--- /dev/null
+++ b/src/Domain/Media/ImageSlot.php
@@ -0,0 +1,21 @@
+<?php
+
+namespace App\Domain\Media;
+
+use App\Framework\Database\Attributes\Column;
+use App\Framework\Database\Attributes\Entity;
+
+#[Entity(tableName: 'image_slots', idColumn: 'id')]
+final readonly class ImageSlot
+{
+    public ?Image $image;
+
+    public function __construct(
+        #[Column(name: 'id', primary: true)]
+        public int $id,
+        #[Column(name: 'slot_name')]
+        public string $slotName,
+        #[Column(name: 'image_id')]
+        public string $imageId,
+    ){}
+}
diff --git a/src/Domain/Media/ImageSlotRepository.php b/src/Domain/Media/ImageSlotRepository.php
new file mode 100644
index 00000000..489eac70
--- /dev/null
+++ b/src/Domain/Media/ImageSlotRepository.php
@@ -0,0 +1,32 @@
+<?php
+
+namespace App\Domain\Media;
+
+use App\Framework\Database\EntityManager;
+
+final readonly class ImageSlotRepository
+{
+    public function __construct(
+        private EntityManager $entityManager
+    ){}
+
+    public function getSlots(): array
+    {
+        return $this->entityManager->findAll(ImageSlot::class);
+    }
+
+    public function findBySlotName(string $slotName): ImageSlot
+    {
+        return $this->entityManager->findOneBy(ImageSlot::class, ['slot_name' => $slotName]);
+    }
+
+    public function findById(string $id): ImageSlot
+    {
+        return $this->entityManager->find(ImageSlot::class, $id);
+    }
+
+    public function save(ImageSlot $imageSlot): object
+    {
+        return $this->entityManager->save($imageSlot);
+    }
+}
diff --git a/src/Domain/Media/ImageSourceSetGenerator.php b/src/Domain/Media/ImageSourceSetGenerator.php
new file mode 100644
index 00000000..f3003235
--- /dev/null
+++ b/src/Domain/Media/ImageSourceSetGenerator.php
@@ -0,0 +1,163 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Domain\Media;
+
+/**
+ * Erzeugt HTML-Source-Sets für responsive Bilder
+ */
+final readonly class ImageSourceSetGenerator
+{
+    /**
+     * Generiert ein vollständiges Picture-Element mit Source-Tags für verschiedene Formate und Größen
+     *
+     * @param Image $image Das Originalbild mit seinen Varianten
+     * @param string $variantType Der Variantentyp (thumbnail, gallery, hero)
+     * @param array $attributes Zusätzliche Attribute für das img-Tag (alt, class, etc.)
+     * @return string HTML Picture-Element
+     */
+    public function generatePictureElement(Image $image, string $variantType = 'gallery', array $attributes = []): string
+    {
+        $sources = [];
+
+        // Varianten nach Format gruppieren
+        $variantsByFormat = $this->groupVariantsByFormat($image, $variantType);
+
+        // Source-Tags für jedes Format generieren
+        foreach (['avif', 'webp', 'jpeg'] as $format) {
+            if (isset($variantsByFormat[$format])) {
+                $sources[] = $this->generateSourceElement($variantsByFormat[$format], ImageFormat::from($format));
+            }
+        }
+
+        // Fallback img-Tag
+        $fallbackImage = $this->getFallbackImage($variantsByFormat, $image);
+        $attributes['src'] = $fallbackImage->getUrl();
+        $attributes['width'] = $fallbackImage->width;
+        $attributes['height'] = $fallbackImage->height;
+
+        if (!isset($attributes['alt'])) {
+            $attributes['alt'] = '';
+        }
+
+        $sources[] = $this->generateImgTag($attributes);
+
+        return '<picture>' . implode('', $sources) . '</picture>';
+    }
+
+    /**
+     * Generiert einen einfachen source-Tag mit srcset
+     *
+     * @param array $variants Bildvarianten für ein bestimmtes Format
+     * @param ImageFormat $format Das Bildformat
+     * @return string HTML source-Element
+     */
+    private function generateSourceElement(array $variants, ImageFormat $format): string
+    {
+        $srcset = [];
+        $sizes = [];
+
+        // Nach Größe sortieren (klein nach groß)
+        usort($variants, function (ImageVariant $a, ImageVariant $b) {
+            return $a->width <=> $b->width;
+        });
+
+        foreach ($variants as $variant) {
+            // URL und Breite für srcset
+            $srcset[] = $variant->getUrl() . ' ' . $variant->width . 'w';
+
+            // Sizes basierend auf Breakpoints
+            $size = ImageSize::from($variant->size);
+            $breakpoint = $size->getBreakpoint();
+
+            if ($breakpoint !== null) {
+                $sizes[] = "(max-width: {$breakpoint}px) {$variant->width}px";
+            }
+        }
+
+        // Größte Variante als Standardgröße hinzufügen
+        $sizes[] = $variants[count($variants) - 1]->width . 'px';
+
+        return sprintf(
+            '<source type="%s" srcset="%s" sizes="%s">',
+            $format->getMimeType(),
+            implode(', ', $srcset),
+            implode(', ', $sizes)
+        );
+    }
+
+    /**
+     * Erzeugt einen img-Tag mit den angegebenen Attributen
+     *
+     * @param array $attributes HTML-Attribute für das img-Tag
+     * @return string HTML img-Element
+     */
+    private function generateImgTag(array $attributes): string
+    {
+        $htmlAttributes = [];
+
+        foreach ($attributes as $name => $value) {
+            $htmlAttributes[] = sprintf('%s="%s"', $name, htmlspecialchars((string)$value));
+        }
+
+        return '<img ' . implode(' ', $htmlAttributes) . '>';
+    }
+
+    /**
+     * Gruppiert Bildvarianten nach Format
+     *
+     * @param Image $image Das Originalbild
+     * @param string $variantType Der Variantentyp
+     * @return array Varianten gruppiert nach Format
+     */
+    private function groupVariantsByFormat(Image $image, string $variantType): array
+    {
+        $variantsByFormat = [];
+
+        foreach ($image->variants as $variant) {
+            if ($variant->variantType === $variantType) {
+                $variantsByFormat[$variant->format][] = $variant;
+            }
+        }
+
+        return $variantsByFormat;
+    }
+
+    /**
+     * Wählt das beste Fallback-Bild aus
+     *
+     * @param array $variantsByFormat Varianten gruppiert nach Format
+     * @param Image $image Das Originalbild
+     * @return ImageVariant Die beste Fallback-Variante
+     */
+    private function getFallbackImage(array $variantsByFormat, Image $image): ImageVariant
+    {
+        // Bevorzugen JPEG als Fallback
+        if (isset($variantsByFormat['jpeg']) && !empty($variantsByFormat['jpeg'])) {
+            // Mittlere Größe als Fallback verwenden
+            $variants = $variantsByFormat['jpeg'];
+            return $variants[min(1, count($variants) - 1)];
+        }
+
+        // Alternativen, falls kein JPEG verfügbar
+        foreach (['webp', 'avif'] as $format) {
+            if (isset($variantsByFormat[$format]) && !empty($variantsByFormat[$format])) {
+                return $variantsByFormat[$format][0];
+            }
+        }
+
+        // Wenn keine Varianten gefunden wurden, das Originalbild verwenden
+        return new ImageVariant(
+            imageId: $image->ulid,
+            variantType: 'original',
+            size: 'original',
+            format: pathinfo($image->filename, PATHINFO_EXTENSION),
+            mimeType: $image->mimeType,
+            fileSize: $image->fileSize,
+            width: $image->width,
+            height: $image->height,
+            filename: $image->filename,
+            path: $image->path,
+        );
+    }
+}
diff --git a/src/Domain/Media/ImageVariant.php b/src/Domain/Media/ImageVariant.php
new file mode 100644
index 00000000..d0970ed8
--- /dev/null
+++ b/src/Domain/Media/ImageVariant.php
@@ -0,0 +1,65 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Domain\Media;
+
+use App\Framework\Database\Attributes\Column;
+use App\Framework\Database\Attributes\Entity;
+
+#[Entity(tableName: 'image_variants')]
+final readonly class ImageVariant
+{
+    /*#[Column(name: 'id', primary: true, autoIncrement: true)]
+    public int $id;*/
+    public function __construct(
+        #[Column(name: 'image_id')]
+        public string $imageId,
+        #[Column(name: 'variant_type')]
+        public string $variantType,
+        // Todo: Implement Size
+        #[Column(name: 'size')]
+        public string $size,
+        #[Column(name: 'format')]
+        public string $format,
+        #[Column(name: 'mime_type')]
+        public string $mimeType,
+        #[Column(name: 'file_size')]
+        public int $fileSize,
+        #[Column(name: 'width')]
+        public int $width,
+        #[Column(name: 'height')]
+        public int $height,
+        #[Column(name: 'filename')]
+        public string $filename,
+        #[Column(name: 'path')]
+        public string $path,
+
+        #[Column(name: 'id', primary: true, autoIncrement: true)]
+        public ?int $id = null,
+    ) {}
+
+    public function getUrl(): string
+    {
+        return '/images/'. $this->filename;
+    }
+
+    public function getVariantType(): ImageVariantType
+    {
+        return ImageVariantType::from($this->variantType);
+    }
+
+    public function getSize(): ImageSize
+    {
+        return ImageSize::from($this->size);
+    }
+
+    public function getFormat(): ImageFormat
+    {
+        return ImageFormat::from($this->format);
+    }
+
+    public function getVariantKey(): string
+    {
+        return "{$this->variantType}_{$this->size}_{$this->format}";
+    }
+}
diff --git a/src/Domain/Media/ImageVariantConfig.php b/src/Domain/Media/ImageVariantConfig.php
new file mode 100644
index 00000000..dbc9d06d
--- /dev/null
+++ b/src/Domain/Media/ImageVariantConfig.php
@@ -0,0 +1,45 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Domain\Media;
+
+final readonly class ImageVariantConfig
+{
+    public static function getAllVariants(): array
+    {
+        $variants = [];
+        
+        foreach (ImageVariantType::cases() as $type) {
+            foreach ($type->getSizes() as $size) {
+                foreach (ImageFormat::cases() as $format) {
+                    $variants[] = [
+                        'type' => $type,
+                        'size' => $size,
+                        'format' => $format,
+                        'width' => $size->getWidth($type),
+                    ];
+                }
+            }
+        }
+        
+        return $variants;
+    }
+
+    public static function getVariantsForType(ImageVariantType $type): array
+    {
+        $variants = [];
+        
+        foreach ($type->getSizes() as $size) {
+            foreach (ImageFormat::cases() as $format) {
+                $variants[] = [
+                    'type' => $type,
+                    'size' => $size,
+                    'format' => $format,
+                    'width' => $size->getWidth($type),
+                ];
+            }
+        }
+        
+        return $variants;
+    }
+}
diff --git a/src/Domain/Media/ImageVariantRepository.php b/src/Domain/Media/ImageVariantRepository.php
new file mode 100644
index 00000000..575fe50b
--- /dev/null
+++ b/src/Domain/Media/ImageVariantRepository.php
@@ -0,0 +1,22 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Domain\Media;
+
+use App\Framework\Database\EntityManager;
+
+final class ImageVariantRepository
+{
+    public function __construct(
+        private EntityManager $entityManager
+    ){}
+
+    public function save(ImageVariant $imageVariant): void
+    {
+        $this->entityManager->save($imageVariant);
+    }
+
+    public function findByFilename(string $filename): ?ImageVariant {
+        return $this->entityManager->findOneBy(ImageVariant::class, ['filename' => $filename]);
+    }
+}
diff --git a/src/Domain/Media/ImageVariantType.php b/src/Domain/Media/ImageVariantType.php
new file mode 100644
index 00000000..d009f818
--- /dev/null
+++ b/src/Domain/Media/ImageVariantType.php
@@ -0,0 +1,31 @@
+<?php
+
+namespace App\Domain\Media;
+
+enum ImageVariantType: string
+{
+    case THUMBNAIL = 'thumbnail';
+    case GALLERY = 'gallery';
+    case HERO = 'hero';
+
+    public function getSizes(): array
+    {
+        return match ($this) {
+            self::THUMBNAIL => [
+                ImageSize::SMALL,
+                ImageSize::MEDIUM,
+            ],
+            self::GALLERY => [
+                ImageSize::SMALL,
+                ImageSize::MEDIUM,
+                ImageSize::LARGE,
+            ],
+            self::HERO => [
+                ImageSize::SMALL,
+                ImageSize::MEDIUM,
+                ImageSize::LARGE,
+                ImageSize::XLARGE,
+            ],
+        };
+    }
+}
diff --git a/src/Domain/Media/ImagickImageProcessor.php b/src/Domain/Media/ImagickImageProcessor.php
new file mode 100644
index 00000000..e8fe735d
--- /dev/null
+++ b/src/Domain/Media/ImagickImageProcessor.php
@@ -0,0 +1,244 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Domain\Media;
+
+use Imagick;
+use ImagickException;
+use ImagickPixel;
+
+/**
+ * ImageMagick-basierter Bildprozessor für optimale Bildqualität
+ */
+final readonly class ImagickImageProcessor implements ImageProcessorInterface
+{
+    /**
+     * @inheritDoc
+     */
+    public function createAllVariants(Image $image): array
+    {
+        $variants = [];
+
+        foreach (ImageVariantConfig::getAllVariants() as $variantConfig) {
+            try {
+                $variant = $this->createVariant($image, $variantConfig);
+                $variants[] = $variant;
+            } catch (\Exception $e) {
+                error_log("Failed to create variant {$variantConfig['type']->value}_{$variantConfig['size']->value}_{$variantConfig['format']->value}: " . $e->getMessage());
+            }
+        }
+
+        return $variants;
+    }
+
+    /**
+     * @inheritDoc
+     */
+    public function createVariantsForType(Image $image, ImageVariantType $type): array
+    {
+        $variants = [];
+
+        foreach (ImageVariantConfig::getVariantsForType($type) as $variantConfig) {
+            try {
+                $variant = $this->createVariant($image, $variantConfig);
+                $variants[] = $variant;
+            } catch (\Exception $e) {
+                error_log("Failed to create variant {$variantConfig['type']->value}_{$variantConfig['size']->value}_{$variantConfig['format']->value}: " . $e->getMessage());
+            }
+        }
+
+        return $variants;
+    }
+
+    /**
+     * Erstellt eine einzelne Bildvariante
+     *
+     * @param Image $image
+     * @param array $config
+     * @return ImageVariant
+     */
+    private function createVariant(Image $image, array $config): ImageVariant
+    {
+        $sourcePath = $image->path . $image->filename;
+
+        /** @var ImageVariantType $type */
+        /** @var ImageSize $size */
+        /** @var ImageFormat $format */
+        $type = $config['type'];
+        $size = $config['size'];
+        $format = $config['format'];
+        $width = $config['width'];
+
+        $filename = $this->generateVariantFilename(
+            $image->filename,
+            $type->value,
+            $size->value,
+            $format->value
+        );
+
+        $destination = $image->path . $filename;
+
+        $actualDimensions = $this->processImage($sourcePath, $destination, $width, $format);
+
+        $fileSize = filesize($destination);
+
+        return new ImageVariant(
+            imageId: $image->ulid,
+            variantType: $type->value,
+            size: $size->value,
+            format: $format->value,
+            mimeType: $format->getMimeType(),
+            fileSize: $fileSize,
+            width: $actualDimensions['width'],
+            height: $actualDimensions['height'],
+            filename: $filename,
+            path: $image->path,
+        );
+    }
+
+    /**
+     * Generiert einen Dateinamen für eine Bildvariante
+     */
+    private function generateVariantFilename(string $originalFilename, string $type, string $size, string $format): string
+    {
+        $pathInfo = pathinfo($originalFilename);
+        return $pathInfo['filename'] . "_{$type}_{$size}.{$format}";
+    }
+
+    /**
+     * Verarbeitet das Bild mit ImageMagick
+     *
+     * @param string $sourcePath
+     * @param string $destination
+     * @param int $maxWidth
+     * @param ImageFormat $format
+     * @return array{width: int, height: int}
+     */
+    private function processImage(string $sourcePath, string $destination, int $maxWidth, ImageFormat $format): array
+    {
+        try {
+            $imagick = new Imagick($sourcePath);
+
+            // Bildorientierung korrigieren (EXIF)
+            $imagick->autoOrientImage();
+
+            // Farbprofil entfernen für kleinere Dateien
+            $imagick->stripImage();
+
+            // Bessere Resampling-Methode
+            $imagick->setImageResolution(72, 72);
+
+            // Original-Dimensionen speichern
+            $originalWidth = $imagick->getImageWidth();
+            $originalHeight = $imagick->getImageHeight();
+
+            // Skalierung nur wenn nötig
+            if ($originalWidth > $maxWidth) {
+                $scale = $maxWidth / $originalWidth;
+                $newWidth = $maxWidth;
+                $newHeight = (int)round($originalHeight * $scale);
+
+                // Lanczos-Filter für beste Qualität
+                $imagick->resizeImage($newWidth, $newHeight, Imagick::FILTER_LANCZOS, 1);
+
+                // Schärfen bei Verkleinerung
+                $this->applySharpeningAfterResize($imagick, $originalWidth, $newWidth);
+            } else {
+                $newWidth = $originalWidth;
+                $newHeight = $originalHeight;
+            }
+
+            // Format-spezifische Optimierungen
+            $this->optimizeForFormat($imagick, $format);
+
+            // Speichern
+            $imagick->writeImage($destination);
+
+            $imagick->destroy();
+
+            return ['width' => $newWidth, 'height' => $newHeight];
+
+        } catch (ImagickException $e) {
+            throw new \RuntimeException('ImageMagick error: ' . $e->getMessage(), 0, $e);
+        }
+    }
+
+    /**
+     * Wendet formatspezifische Optimierungen an
+     */
+    private function optimizeForFormat(Imagick $imagick, ImageFormat $format): void
+    {
+        match ($format) {
+            ImageFormat::JPEG => $this->optimizeJpeg($imagick),
+            ImageFormat::WEBP => $this->optimizeWebP($imagick),
+            ImageFormat::AVIF => $this->optimizeAvif($imagick),
+        };
+    }
+
+    /**
+     * Optimiert JPEG-Einstellungen
+     */
+    private function optimizeJpeg(Imagick $imagick): void
+    {
+        $imagick->setImageFormat('jpeg');
+        $imagick->setImageCompressionQuality(ImageFormat::JPEG->getQuality());
+        $imagick->setImageCompression(Imagick::COMPRESSION_JPEG);
+
+        // Progressive JPEG für bessere Ladezeiten
+        $imagick->setInterlaceScheme(Imagick::INTERLACE_PLANE);
+
+        // Chroma-Subsampling für kleinere Dateien
+        $imagick->setSamplingFactors(['2x2', '1x1', '1x1']);
+    }
+
+    /**
+     * Optimiert WebP-Einstellungen
+     */
+    private function optimizeWebP(Imagick $imagick): void
+    {
+        $imagick->setImageFormat('webp');
+        $imagick->setImageCompressionQuality(ImageFormat::WEBP->getQuality());
+
+        // WebP-spezifische Optionen
+        $imagick->setOption('webp:lossless', 'false');
+        $imagick->setOption('webp:alpha-quality', '85');
+        $imagick->setOption('webp:method', '4'); // Balancierte Kompression
+    }
+
+    /**
+     * Optimiert AVIF-Einstellungen
+     */
+    private function optimizeAvif(Imagick $imagick): void
+    {
+        // Wenn die ImageMagick-Version AVIF direkt unterstützt
+        if (in_array('AVIF', Imagick::queryFormats())) {
+            $imagick->setImageFormat('avif');
+            $imagick->setImageCompressionQuality(ImageFormat::AVIF->getQuality());
+
+            // AVIF-spezifische Optionen, falls unterstützt
+            $imagick->setOption('avif:speed', '6'); // Balancierte Kompression
+        } else {
+            // Fallback: Speichern als WebP wenn AVIF nicht unterstützt wird
+            $this->optimizeWebP($imagick);
+        }
+    }
+
+    /**
+     * Wendet intelligente Schärfung an, um Details zu verbessern
+     */
+    private function applySharpeningAfterResize(Imagick $imagick, int $originalWidth, int $newWidth): void
+    {
+        $scaleFactor = $newWidth / $originalWidth;
+
+        // Nur bei signifikanter Verkleinerung schärfen
+        if ($scaleFactor < 0.8) {
+            // Stärke der Schärfung an die Verkleinerung anpassen
+            $radius = 0.5;
+            $sigma = 0.5;
+            $amount = 0.8 + ((1 - $scaleFactor) * 0.3); // Mehr Schärfung bei größerer Verkleinerung
+            $threshold = 0.05;
+
+            $imagick->unsharpMaskImage($radius, $sigma, $amount, $threshold);
+        }
+    }
+}
diff --git a/src/Domain/Media/Migrations/AddSizeToImageVariantsTable.php b/src/Domain/Media/Migrations/AddSizeToImageVariantsTable.php
new file mode 100644
index 00000000..99696972
--- /dev/null
+++ b/src/Domain/Media/Migrations/AddSizeToImageVariantsTable.php
@@ -0,0 +1,30 @@
+<?php
+
+namespace App\Domain\Media\Migrations;
+
+use App\Framework\Database\ConnectionInterface;
+use App\Framework\Database\Migration\Migration;
+
+final readonly class AddSizeToImageVariantsTable implements Migration
+{
+
+    public function up(ConnectionInterface $connection): void
+    {
+        $connection->execute("ALTER TABLE image_variants ADD COLUMN size VARCHAR(25) NOT NULL DEFAULT ''");
+    }
+
+    public function down(ConnectionInterface $connection): void
+    {
+        $connection->execute("ALTER TABLE image_variants DROP COLUMN size");
+    }
+
+    public function getVersion(): string
+    {
+        return "005";
+    }
+
+    public function getDescription(): string
+    {
+        return "Add Size to Image Slot Table";
+    }
+}
diff --git a/src/Domain/Media/Migrations/CreateImageSlotsTable.php b/src/Domain/Media/Migrations/CreateImageSlotsTable.php
new file mode 100644
index 00000000..2f31edf2
--- /dev/null
+++ b/src/Domain/Media/Migrations/CreateImageSlotsTable.php
@@ -0,0 +1,43 @@
+<?php
+
+namespace App\Domain\Media\Migrations;
+
+use App\Framework\Database\ConnectionInterface;
+use App\Framework\Database\Migration\Migration;
+
+final readonly class CreateImageSlotsTable implements Migration
+{
+
+    public function up(ConnectionInterface $connection): void
+    {
+        $sql = <<<SQL
+            CREATE TABLE IF NOT EXISTS image_slots (
+                id              INT AUTO_INCREMENT,
+                image_id        VARCHAR(26) NOT NULL,
+                slot_name       VARCHAR(50) NOT NULL,
+                created_at      TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+                updated_at      TIMESTAMP NULL DEFAULT NULL,
+
+                PRIMARY KEY (id)
+                )
+                ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
+SQL;
+
+        $connection->query($sql);
+    }
+
+    public function down(ConnectionInterface $connection): void
+    {
+        $connection->execute("DROP TABLE IF EXISTS image_slots");
+    }
+
+    public function getVersion(): string
+    {
+        return "004";
+    }
+
+    public function getDescription(): string
+    {
+        return "Create Image Slot Table";
+    }
+}
diff --git a/src/Domain/Media/Migrations/CreateImageVariantsTable.php b/src/Domain/Media/Migrations/CreateImageVariantsTable.php
new file mode 100644
index 00000000..4c37ad0d
--- /dev/null
+++ b/src/Domain/Media/Migrations/CreateImageVariantsTable.php
@@ -0,0 +1,76 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Domain\Media\Migrations;
+
+use App\Framework\Database\ConnectionInterface;
+use App\Framework\Database\Migration\Migration;
+
+final class CreateImageVariantsTable implements Migration
+{
+
+    public function up(ConnectionInterface $connection): void
+    {
+        $sql = <<<SQL
+            CREATE TABLE IF NOT EXISTS image_variants (
+                id              INT AUTO_INCREMENT,
+                image_id        VARCHAR(26) NOT NULL,
+                variant_type    VARCHAR(50) NOT NULL,
+                format          VARCHAR(25) NOT NULL,
+                mime_type       VARCHAR(100) NOT NULL,
+                width           INT NOT NULL,
+                height          INT NOT NULL,
+                file_size       BIGINT NOT NULL,
+                filename        VARCHAR(500) NOT NULL,
+                path            VARCHAR(500) NOT NULL,
+                created_at      TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+                updated_at      TIMESTAMP NULL DEFAULT NULL,
+
+                PRIMARY KEY (id),
+                UNIQUE KEY uk_image_variants_combination (image_id, variant_type, format),
+                CONSTRAINT fk_image_variants_image_id
+                    FOREIGN KEY (image_id) REFERENCES images(ulid) ON DELETE CASCADE,
+                INDEX idx_image_variants_lookup (image_id, variant_type)
+            ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
+SQL;
+
+        $connection->query($sql);
+    }
+
+    public function down(ConnectionInterface $connection): void
+    {
+        $this->dropExistingConstraints($connection);
+
+        $connection->execute("DROP TABLE IF EXISTS image_variants");
+    }
+
+    public function getVersion(): string
+    {
+        return "003";
+    }
+
+    public function getDescription(): string
+    {
+        return "Create Image Variant Table";
+    }
+
+    private function dropExistingConstraints(ConnectionInterface $connection): void
+    {
+        try {
+            // Alle bestehenden Foreign Key Constraints für diese Tabelle finden und entfernen
+            $constraints = $connection->query("
+                SELECT CONSTRAINT_NAME
+                FROM information_schema.KEY_COLUMN_USAGE
+                WHERE TABLE_SCHEMA = DATABASE()
+                AND TABLE_NAME = 'image_variants'
+                AND REFERENCED_TABLE_NAME IS NOT NULL
+            ")->fetchAll();
+
+            foreach ($constraints as $constraint) {
+                $connection->execute('ALTER TABLE image_variants DROP FOREIGN KEY ' . $constraint['CONSTRAINT_NAME']);
+            }
+        } catch (\Exception $e) {
+            // Ignorieren wenn Tabelle nicht existiert oder keine Constraints vorhanden sind
+        }
+    }
+}
diff --git a/src/Domain/Media/Migrations/CreateImagesTable.php b/src/Domain/Media/Migrations/CreateImagesTable.php
new file mode 100644
index 00000000..58f6194e
--- /dev/null
+++ b/src/Domain/Media/Migrations/CreateImagesTable.php
@@ -0,0 +1,52 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Domain\Media\Migrations;
+
+use App\Framework\Database\ConnectionInterface;
+use App\Framework\Database\Migration\Migration;
+
+final class CreateImagesTable implements Migration
+{
+
+    public function up(ConnectionInterface $connection): void
+    {
+        $sql = <<<SQL
+            CREATE TABLE IF NOT EXISTS images (
+                ulid                VARCHAR(26) NOT NULL,
+                filename            VARCHAR(255) NOT NULL,
+                original_filename   VARCHAR(255) NOT NULL,
+                mime_type           VARCHAR(100) NOT NULL,
+                file_size           BIGINT NOT NULL,
+                width               INT UNSIGNED NOT NULL,
+                height              INT UNSIGNED NOT NULL,
+                hash                VARCHAR(255) NOT NULL,
+                path                VARCHAR(500) NOT NULL,
+                alt_text            TEXT NOT NULL,
+                created_at          TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+                updated_at          TIMESTAMP NULL DEFAULT NULL,
+
+                PRIMARY KEY (ulid),
+                UNIQUE KEY uk_images_hash (hash),
+                UNIQUE KEY uk_images_ulid (ulid)
+            ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
+SQL;
+
+        $connection->query($sql);
+    }
+
+    public function down(ConnectionInterface $connection): void
+    {
+        $connection->execute("DROP TABLE IF EXISTS images");
+    }
+
+    public function getVersion(): string
+    {
+        return "002";
+    }
+
+    public function getDescription(): string
+    {
+        return "Create Image Table";
+    }
+}
diff --git a/src/Domain/Media/Migrations/UpdateImageVariantsConstraint.php b/src/Domain/Media/Migrations/UpdateImageVariantsConstraint.php
new file mode 100644
index 00000000..1e4d9bf5
--- /dev/null
+++ b/src/Domain/Media/Migrations/UpdateImageVariantsConstraint.php
@@ -0,0 +1,35 @@
+<?php
+
+namespace App\Domain\Media\Migrations;
+
+use App\Framework\Database\ConnectionInterface;
+use App\Framework\Database\Migration\Migration;
+
+final readonly class UpdateImageVariantsConstraint implements Migration
+{
+    public function up(ConnectionInterface $connection): void
+    {
+        // Bestehenden Constraint entfernen
+        $connection->execute("ALTER TABLE image_variants DROP INDEX uk_image_variants_combination");
+
+        // Neuen Constraint mit size-Spalte hinzufügen
+        $connection->execute("ALTER TABLE image_variants ADD UNIQUE KEY uk_image_variants_combination (image_id, variant_type, size, format)");
+    }
+
+    public function down(ConnectionInterface $connection): void
+    {
+        // Zurück zum ursprünglichen Constraint
+        $connection->execute("ALTER TABLE image_variants DROP INDEX uk_image_variants_combination");
+        $connection->execute("ALTER TABLE image_variants ADD UNIQUE KEY uk_image_variants_combination (image_id, variant_type, format)");
+    }
+
+    public function getVersion(): string
+    {
+        return "006";
+    }
+
+    public function getDescription(): string
+    {
+        return "Update unique constraint to include size column";
+    }
+}
diff --git a/src/Domain/Media/README.md b/src/Domain/Media/README.md
new file mode 100644
index 00000000..c183d44b
--- /dev/null
+++ b/src/Domain/Media/README.md
@@ -0,0 +1,92 @@
+# Media Modul
+
+Dieses Modul verwaltet Bilder und erstellt optimierte Varianten für responsive Webseiten.
+
+## Hauptfunktionen
+
+- Automatische Erstellung von Bildvarianten in verschiedenen Größen und Formaten (AVIF, WebP, JPEG)
+- Hochwertige Bildoptimierung mit ImageMagick (oder GD als Fallback)
+- Responsive Bildausgabe mit HTML Picture-Element und Source-Sets
+
+## Verwendung
+
+### Erzeugen von Bildvarianten
+
+```php
+// Direkter Zugriff (automatische Erkennung der besten Implementierung)
+$processor = new ImageProcessor();
+
+// Alle Varianten
+$variants = $processor->createAllVariants($image);
+
+// Nur bestimmte Typen
+$thumbnails = $processor->createVariantsForType($image, ImageVariantType::THUMBNAIL);
+
+// Alternativ via DI Container
+$processor = $container->get(ImageProcessorInterface::class);
+```
+
+### Spezifische Implementierungen
+
+```php
+// ImageMagick direkt verwenden
+$imagickProcessor = new ImagickImageProcessor();
+$variants = $imagickProcessor->createAllVariants($image);
+
+// Oder GD
+$gdProcessor = new GdImageProcessor();
+$variants = $gdProcessor->createAllVariants($image);
+
+// Factory für automatische Auswahl
+$optimalProcessor = ImageProcessorFactory::create();
+```
+
+### HTML für responsive Bilder generieren
+
+```php
+$generator = new ImageSourceSetGenerator();
+
+// Einfache Verwendung
+$html = $generator->generatePictureElement($image, 'gallery');
+
+// Mit zusätzlichen Attributen
+$html = $generator->generatePictureElement($image, 'hero', [
+    'alt' => 'Beschreibung des Bildes',
+    'class' => 'hero-image',
+    'loading' => 'lazy',
+]);
+```
+
+## Konfiguration
+
+Die Konfiguration der Bildgrößen und -formate erfolgt über Enums:
+
+- `ImageVariantType`: Definiert die Verwendungszwecke (Thumbnail, Gallery, Hero)
+- `ImageSize`: Definiert die verfügbaren Größen und deren Breakpoints
+- `ImageFormat`: Definiert die unterstützten Formate und deren Qualitätseinstellungen
+
+## Architektur
+
+- `ImageProcessorInterface`: Gemeinsame Schnittstelle für alle Prozessoren
+- `ImagickImageProcessor`: Hochwertige Optimierung mit ImageMagick
+- `GdImageProcessor`: Fallback-Implementierung mit GD
+- `ImageProcessor`: Adapter für einfachen Zugriff und Abwärtskompatibilität
+- `ImageProcessorFactory`: Erstellt optimale Implementierung basierend auf verfügbaren Extensions
+
+## Technische Details
+
+- Automatische Auswahl zwischen ImageMagick und GD je nach Verfügbarkeit
+- Optimierte Kompression für jedes Format
+- Intelligente Schärfung bei Verkleinerung
+- Erhaltung von Transparenz bei unterstützten Formaten
+
+## Beispiel: Vollständiges HTML-Ausgabe
+
+```html
+<picture>
+  <source type="image/avif" srcset="image_gallery_small.avif 400w, image_gallery_medium.avif 800w, image_gallery_large.avif 1200w" sizes="(max-width: 768px) 400px, (max-width: 1024px) 800px, 1200px">
+  <source type="image/webp" srcset="image_gallery_small.webp 400w, image_gallery_medium.webp 800w, image_gallery_large.webp 1200w" sizes="(max-width: 768px) 400px, (max-width: 1024px) 800px, 1200px">
+  <source type="image/jpeg" srcset="image_gallery_small.jpeg 400w, image_gallery_medium.jpeg 800w, image_gallery_large.jpeg 1200w" sizes="(max-width: 768px) 400px, (max-width: 1024px) 800px, 1200px">
+  <img src="image_gallery_medium.jpeg" width="800" height="600" alt="Beschreibung" loading="lazy">
+</picture>
+```
diff --git a/src/Domain/Media/SaveImageFile.php b/src/Domain/Media/SaveImageFile.php
new file mode 100644
index 00000000..8211c2e4
--- /dev/null
+++ b/src/Domain/Media/SaveImageFile.php
@@ -0,0 +1,19 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Domain\Media;
+
+use App\Framework\Http\UploadedFile;
+use function move_uploaded_file;
+
+final readonly class SaveImageFile
+{
+    public function __invoke(Image $image, string $tempFileName): bool
+    {
+        $directory = $image->path;
+        if (!is_dir($directory)) {
+            mkdir($directory, 0755, true);
+        }
+        return move_uploaded_file($tempFileName, $image->path . $image->filename);
+    }
+}
diff --git a/src/Domain/Meta/Entity/MetaEntry.php b/src/Domain/Meta/Entity/MetaEntry.php
new file mode 100644
index 00000000..118bbf8c
--- /dev/null
+++ b/src/Domain/Meta/Entity/MetaEntry.php
@@ -0,0 +1,111 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Domain\Meta\Entity;
+
+use App\Domain\Meta\ValueObject\MetaData;
+
+class MetaEntry
+{
+    public function __construct(
+        public ?int $id = null,
+        public ?string $routePattern = null,
+        public ?string $entityType = null,
+        public ?int $entityId = null,
+        public ?MetaData $metaData = null,
+        public int $priority = 0,
+        public bool $active = true,
+        public ?\DateTimeImmutable $createdAt = null,
+        public ?\DateTimeImmutable $updatedAt = null,
+    ) {
+        $this->metaData ??= new MetaData();
+        $this->createdAt ??= new \DateTimeImmutable();
+        $this->updatedAt ??= new \DateTimeImmutable();
+    }
+
+    public static function forRoute(string $routePattern, MetaData $metaData, int $priority = 0): self
+    {
+        return new self(
+            routePattern: $routePattern,
+            metaData: $metaData,
+            priority: $priority
+        );
+    }
+
+    public static function forEntity(string $entityType, int $entityId, MetaData $metaData, int $priority = 0): self
+    {
+        return new self(
+            entityType: $entityType,
+            entityId: $entityId,
+            metaData: $metaData,
+            priority: $priority
+        );
+    }
+
+    public function updateMetaData(MetaData $metaData): void
+    {
+        $this->metaData = $metaData;
+        $this->updatedAt = new \DateTimeImmutable();
+    }
+
+    public function activate(): void
+    {
+        $this->active = true;
+        $this->updatedAt = new \DateTimeImmutable();
+    }
+
+    public function deactivate(): void
+    {
+        $this->active = false;
+        $this->updatedAt = new \DateTimeImmutable();
+    }
+
+    public function isRouteEntry(): bool
+    {
+        return $this->routePattern !== null;
+    }
+
+    public function isEntityEntry(): bool
+    {
+        return $this->entityType !== null && $this->entityId !== null;
+    }
+
+    public function matchesRoute(string $route): bool
+    {
+        if (!$this->isRouteEntry()) {
+            return false;
+        }
+
+        // Exakte Übereinstimmung
+        if ($this->routePattern === $route) {
+            return true;
+        }
+
+        // Pattern-Matching (einfache Wildcard-Unterstützung)
+        $pattern = str_replace(['*', '{', '}'], ['.*', '(?P<', '>[^/]+)'], $this->routePattern);
+        return (bool) preg_match('#^' . $pattern . '$#', $route);
+    }
+
+    public function matchesEntity(string $entityType, int $entityId): bool
+    {
+        return $this->isEntityEntry()
+            && $this->entityType === $entityType
+            && $this->entityId === $entityId;
+    }
+
+    public function toArray(): array
+    {
+        return [
+            'id' => $this->id,
+            'route_pattern' => $this->routePattern,
+            'entity_type' => $this->entityType,
+            'entity_id' => $this->entityId,
+            'meta_data' => $this->metaData?->toArray(),
+            'priority' => $this->priority,
+            'active' => $this->active,
+            'created_at' => $this->createdAt?->format('Y-m-d H:i:s'),
+            'updated_at' => $this->updatedAt?->format('Y-m-d H:i:s'),
+        ];
+    }
+}
diff --git a/src/Domain/Meta/Http/Controller/MetaAdminController.php b/src/Domain/Meta/Http/Controller/MetaAdminController.php
new file mode 100644
index 00000000..735ef43f
--- /dev/null
+++ b/src/Domain/Meta/Http/Controller/MetaAdminController.php
@@ -0,0 +1,405 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Domain\Meta\Http\Controller;
+
+use App\Domain\Meta\Entity\MetaEntry;
+use App\Domain\Meta\Http\Request\MetaRequest;
+use App\Domain\Meta\Repository\MetaRepositoryInterface;
+use App\Domain\Meta\Service\MetaManager;
+use App\Domain\Meta\Service\MetaTemplateResolver;
+use App\Domain\Meta\ValueObject\MetaData;
+use App\Framework\Http\JsonResult;
+use App\Framework\Http\Status;
+use App\Framework\Router\Attributes\Route;
+use App\Framework\Router\Method;
+
+final class MetaAdminController
+{
+    public function __construct(
+        private readonly MetaRepositoryInterface $repository,
+        private readonly MetaManager $metaManager,
+        private readonly ?MetaTemplateResolver $templateResolver = null,
+    ) {}
+
+    /**
+     * Listet alle Meta-Einträge auf
+     */
+    #[Route(path: '/admin/meta', method: Method::GET)]
+    public function listMeta(): JsonResult
+    {
+        try {
+            $page = (int) ($_GET['page'] ?? 1);
+            $limit = (int) ($_GET['limit'] ?? 50);
+            $search = $_GET['search'] ?? '';
+
+            $offset = ($page - 1) * $limit;
+
+            if ($search) {
+                $entries = $this->repository->search($search, $limit);
+                $total = count($entries);
+            } else {
+                $entries = $this->repository->findAll($limit, $offset);
+                $total = $this->repository->count();
+            }
+
+            return new JsonResult([
+                'success' => true,
+                'data' => array_map(fn($entry) => $entry->toArray(), $entries),
+                'pagination' => [
+                    'page' => $page,
+                    'limit' => $limit,
+                    'total' => $total,
+                    'pages' => ceil($total / $limit),
+                ]
+            ]);
+        } catch (\Exception $e) {
+            return new JsonResult([
+                'success' => false,
+                'error' => $e->getMessage()
+            ], Status::INTERNAL_SERVER_ERROR);
+        }
+    }
+
+    /**
+     * Zeigt einen einzelnen Meta-Eintrag
+     */
+    #[Route(path: '/admin/meta/{id}', method: Method::GET)]
+    public function getMeta(int $id): JsonResult
+    {
+        try {
+            $entry = $this->repository->findById($id);
+
+            if (!$entry) {
+                return new JsonResult([
+                    'success' => false,
+                    'error' => 'Meta-Eintrag nicht gefunden'
+                ], Status::NOT_FOUND);
+            }
+
+            return new JsonResult([
+                'success' => true,
+                'data' => $entry->toArray()
+            ]);
+        } catch (\Exception $e) {
+            return new JsonResult([
+                'success' => false,
+                'error' => $e->getMessage()
+            ], Status::INTERNAL_SERVER_ERROR);
+        }
+    }
+
+    /**
+     * Erstellt einen neuen Meta-Eintrag
+     */
+    #[Route(path: '/admin/meta', method: Method::POST)]
+    public function createMeta(MetaRequest $request): JsonResult
+    {
+        try {
+            // Validierung: Entweder Route oder Entity muss angegeben sein
+            if (!$request->routePattern && (!$request->entityType || !$request->entityId)) {
+                return new JsonResult([
+                    'success' => false,
+                    'error' => 'Entweder Route-Pattern oder Entity-Typ/ID muss angegeben werden'
+                ], Status::BAD_REQUEST);
+            }
+
+            // Prüfe auf Duplikate
+            if ($request->routePattern && $this->repository->routePatternExists($request->routePattern)) {
+                return new JsonResult([
+                    'success' => false,
+                    'error' => 'Route-Pattern existiert bereits'
+                ], Status::CONFLICT);
+            }
+
+            if ($request->entityType && $request->entityId &&
+                $this->repository->entityMetaExists($request->entityType, $request->entityId)) {
+                return new JsonResult([
+                    'success' => false,
+                    'error' => 'Meta-Daten für diese Entity existieren bereits'
+                ], Status::CONFLICT);
+            }
+
+            // Template validieren
+            if ($this->templateResolver) {
+                $this->validateTemplates($request);
+            }
+
+            $metaData = new MetaData(
+                title: $request->title,
+                description: $request->description,
+                keywords: $request->getKeywordsAsArray(),
+                ogTitle: $request->ogTitle,
+                ogDescription: $request->ogDescription,
+                ogImage: $request->ogImage,
+                ogType: $request->ogType,
+                twitterCard: $request->twitterCard,
+                twitterSite: $request->twitterSite,
+                canonical: $request->canonical,
+                customMeta: $request->customMeta
+            );
+
+            $entry = new MetaEntry(
+                routePattern: $request->routePattern,
+                entityType: $request->entityType,
+                entityId: $request->entityId,
+                metaData: $metaData,
+                priority: $request->priority,
+                active: $request->active
+            );
+
+            $savedEntry = $this->repository->save($entry);
+
+            // Cache invalidieren
+            if ($request->routePattern) {
+                $this->metaManager->invalidateCache($request->routePattern);
+            }
+
+            return new JsonResult([
+                'success' => true,
+                'data' => $savedEntry->toArray()
+            ], Status::CREATED);
+        } catch (\Exception $e) {
+            return new JsonResult([
+                'success' => false,
+                'error' => $e->getMessage()
+            ], Status::INTERNAL_SERVER_ERROR);
+        }
+    }
+
+    /**
+     * Aktualisiert einen Meta-Eintrag
+     */
+    #[Route(path: '/admin/meta/{id}', method: Method::PUT)]
+    public function updateMeta(int $id, MetaRequest $request): JsonResult
+    {
+        try {
+            $entry = $this->repository->findById($id);
+
+            if (!$entry) {
+                return new JsonResult([
+                    'success' => false,
+                    'error' => 'Meta-Eintrag nicht gefunden'
+                ], Status::NOT_FOUND);
+            }
+
+            // Prüfe auf Duplikate (außer dem aktuellen Eintrag)
+            if ($request->routePattern &&
+                $this->repository->routePatternExists($request->routePattern, $id)) {
+                return new JsonResult([
+                    'success' => false,
+                    'error' => 'Route-Pattern existiert bereits'
+                ], Status::CONFLICT);
+            }
+
+            if ($request->entityType && $request->entityId &&
+                $this->repository->entityMetaExists($request->entityType, $request->entityId, $id)) {
+                return new JsonResult([
+                    'success' => false,
+                    'error' => 'Meta-Daten für diese Entity existieren bereits'
+                ], Status::CONFLICT);
+            }
+
+            // Template validieren
+            if ($this->templateResolver) {
+                $this->validateTemplates($request);
+            }
+
+            $metaData = new MetaData(
+                title: $request->title,
+                description: $request->description,
+                keywords: $request->getKeywordsAsArray(),
+                ogTitle: $request->ogTitle,
+                ogDescription: $request->ogDescription,
+                ogImage: $request->ogImage,
+                ogType: $request->ogType,
+                twitterCard: $request->twitterCard,
+                twitterSite: $request->twitterSite,
+                canonical: $request->canonical,
+                customMeta: $request->customMeta
+            );
+
+            $entry->routePattern = $request->routePattern;
+            $entry->entityType = $request->entityType;
+            $entry->entityId = $request->entityId;
+            $entry->priority = $request->priority;
+            $entry->active = $request->active;
+            $entry->updateMetaData($metaData);
+
+            $savedEntry = $this->repository->save($entry);
+
+            // Cache invalidieren
+            $this->metaManager->invalidateAllCache();
+
+            return new JsonResult([
+                'success' => true,
+                'data' => $savedEntry->toArray()
+            ]);
+        } catch (\Exception $e) {
+            return new JsonResult([
+                'success' => false,
+                'error' => $e->getMessage()
+            ], Status::INTERNAL_SERVER_ERROR);
+        }
+    }
+
+    /**
+     * Löscht einen Meta-Eintrag
+     */
+    #[Route(path: '/admin/meta/{id}', method: Method::DELETE)]
+    public function deleteMeta(int $id): JsonResult
+    {
+        try {
+            $entry = $this->repository->findById($id);
+
+            if (!$entry) {
+                return new JsonResult([
+                    'success' => false,
+                    'error' => 'Meta-Eintrag nicht gefunden'
+                ], Status::NOT_FOUND);
+            }
+
+            $deleted = $this->repository->delete($id);
+
+            if ($deleted) {
+                // Cache invalidieren
+                $this->metaManager->invalidateAllCache();
+
+                return new JsonResult([
+                    'success' => true,
+                    'message' => 'Meta-Eintrag erfolgreich gelöscht'
+                ]);
+            } else {
+                return new JsonResult([
+                    'success' => false,
+                    'error' => 'Meta-Eintrag konnte nicht gelöscht werden'
+                ], Status::INTERNAL_SERVER_ERROR);
+            }
+        } catch (\Exception $e) {
+            return new JsonResult([
+                'success' => false,
+                'error' => $e->getMessage()
+            ], Status::INTERNAL_SERVER_ERROR);
+        }
+    }
+
+    /**
+     * Aktiviert/Deaktiviert einen Meta-Eintrag
+     */
+    #[Route(path: '/admin/meta/{id}/toggle', method: Method::POST)]
+    public function toggleMeta(int $id): JsonResult
+    {
+        try {
+            $entry = $this->repository->findById($id);
+
+            if (!$entry) {
+                return new JsonResult([
+                    'success' => false,
+                    'error' => 'Meta-Eintrag nicht gefunden'
+                ], Status::NOT_FOUND);
+            }
+
+            if ($entry->active) {
+                $entry->deactivate();
+            } else {
+                $entry->activate();
+            }
+
+            $savedEntry = $this->repository->save($entry);
+
+            // Cache invalidieren
+            $this->metaManager->invalidateAllCache();
+
+            return new JsonResult([
+                'success' => true,
+                'data' => $savedEntry->toArray()
+            ]);
+        } catch (\Exception $e) {
+            return new JsonResult([
+                'success' => false,
+                'error' => $e->getMessage()
+            ], Status::INTERNAL_SERVER_ERROR);
+        }
+    }
+
+    /**
+     * Validiert Template-Syntax
+     */
+    #[Route(path: '/admin/meta/validate-template', method: Method::POST)]
+    public function validateTemplate(): JsonResult
+    {
+        try {
+            $template = $_POST['template'] ?? '';
+
+            if (!$this->templateResolver) {
+                return new JsonResult([
+                    'success' => true,
+                    'message' => 'Template-Validation nicht verfügbar'
+                ]);
+            }
+
+            $errors = $this->templateResolver->validateTemplate($template);
+            $placeholders = $this->templateResolver->extractPlaceholders($template);
+
+            return new JsonResult([
+                'success' => true,
+                'data' => [
+                    'valid' => empty($errors),
+                    'errors' => $errors,
+                    'placeholders' => $placeholders
+                ]
+            ]);
+        } catch (\Exception $e) {
+            return new JsonResult([
+                'success' => false,
+                'error' => $e->getMessage()
+            ], Status::INTERNAL_SERVER_ERROR);
+        }
+    }
+
+    /**
+     * Cache für Meta-Daten leeren
+     */
+    #[Route(path: '/admin/meta/clear-cache', method: Method::POST)]
+    public function clearCache(): JsonResult
+    {
+        try {
+            $this->metaManager->invalidateAllCache();
+
+            return new JsonResult([
+                'success' => true,
+                'message' => 'Meta-Cache erfolgreich geleert'
+            ]);
+        } catch (\Exception $e) {
+            return new JsonResult([
+                'success' => false,
+                'error' => $e->getMessage()
+            ], Status::INTERNAL_SERVER_ERROR);
+        }
+    }
+
+    private function validateTemplates(MetaRequest $request): void
+    {
+        if (!$this->templateResolver) {
+            return;
+        }
+
+        $templates = [
+            'title' => $request->title,
+            'description' => $request->description,
+            'ogTitle' => $request->ogTitle,
+            'ogDescription' => $request->ogDescription,
+            'canonical' => $request->canonical,
+        ];
+
+        foreach ($templates as $field => $template) {
+            if ($template) {
+                $errors = $this->templateResolver->validateTemplate($template);
+                if (!empty($errors)) {
+                    throw new \InvalidArgumentException("Template-Fehler in {$field}: " . implode(', ', $errors));
+                }
+            }
+        }
+    }
+}
diff --git a/src/Domain/Meta/Http/Middleware/MetaMiddleware.php b/src/Domain/Meta/Http/Middleware/MetaMiddleware.php
new file mode 100644
index 00000000..43485acc
--- /dev/null
+++ b/src/Domain/Meta/Http/Middleware/MetaMiddleware.php
@@ -0,0 +1,104 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Domain\Meta\Http\Middleware;
+
+use App\Domain\Meta\Service\MetaManager;
+use App\Framework\Http\Request;
+use App\Framework\Http\Response;
+use App\Framework\View\RenderContext;
+
+final readonly class MetaMiddleware
+{
+    public function __construct(
+        private MetaManager $metaManager,
+        private ?RenderContext $renderContext = null,
+    ) {}
+
+    public function handle(Request $request, callable $next): Response
+    {
+        // Meta-Daten automatisch für Request laden
+        $context = $this->extractContextFromRequest($request);
+        $meta = $this->metaManager->resolveForRequest($request, $context);
+
+        // In RenderContext injizieren (falls verfügbar)
+        if ($this->renderContext && !$meta->isEmpty()) {
+            $this->renderContext->setMeta($meta);
+        }
+
+        // Meta-Daten für späteren Zugriff am Request speichern
+        $request->setAttribute('meta', $meta);
+
+        $response = $next($request);
+
+        // Für HTML-Responses: Meta-Tags automatisch in <head> injizieren
+        if ($this->shouldInjectMeta($response)) {
+            $this->injectMetaIntoResponse($response, $meta);
+        }
+
+        return $response;
+    }
+
+    private function extractContextFromRequest(Request $request): array
+    {
+        $context = [];
+
+        // Route-Parameter hinzufügen
+        if ($params = $request->getRouteParameters()) {
+            $context = array_merge($context, $params);
+        }
+
+        // Query-Parameter hinzufügen
+        if ($query = $request->getQueryParams()) {
+            $context['query'] = $query;
+        }
+
+        // User-Info hinzufügen (falls verfügbar)
+        if ($user = $request->getAttribute('user')) {
+            $context['user'] = $user;
+        }
+
+        return $context;
+    }
+
+    private function shouldInjectMeta(Response $response): bool
+    {
+        $contentType = $response->getHeader('Content-Type') ?? '';
+
+        return str_contains($contentType, 'text/html') ||
+               (empty($contentType) && $this->isHtmlContent($response->getBody()));
+    }
+
+    private function isHtmlContent(string $content): bool
+    {
+        return str_contains($content, '<html') || str_contains($content, '<head');
+    }
+
+    private function injectMetaIntoResponse(Response $response, \App\Domain\Meta\ValueObject\MetaData $meta): void
+    {
+        $content = $response->getBody();
+        $metaHtml = $meta->render();
+
+        if (empty($metaHtml)) {
+            return;
+        }
+
+        // Versuche Meta-Tags in <head> zu injizieren
+        if (preg_match('/<head[^>]*>/i', $content, $matches, PREG_OFFSET_CAPTURE)) {
+            $headStart = $matches[0][1] + strlen($matches[0][0]);
+            $newContent = substr_replace($content, "\n" . $metaHtml . "\n", $headStart, 0);
+            $response->setBody($newContent);
+        }
+        // Fallback: Vor </head> einfügen
+        elseif (stripos($content, '</head>') !== false) {
+            $newContent = str_ireplace('</head>', $metaHtml . "\n</head>", $content);
+            $response->setBody($newContent);
+        }
+        // Letzter Fallback: Nach <html> einfügen
+        elseif (preg_match('/<html[^>]*>/i', $content)) {
+            $newContent = preg_replace('/(<html[^>]*>)/i', '$1' . "\n<head>\n" . $metaHtml . "\n</head>", $content);
+            $response->setBody($newContent);
+        }
+    }
+}
diff --git a/src/Domain/Meta/Http/Request/MetaRequest.php b/src/Domain/Meta/Http/Request/MetaRequest.php
new file mode 100644
index 00000000..bf154743
--- /dev/null
+++ b/src/Domain/Meta/Http/Request/MetaRequest.php
@@ -0,0 +1,80 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Domain\Meta\Http\Request;
+
+use App\Framework\Validation\Attributes\Required;
+use App\Framework\Validation\Attributes\MaxLength;
+use App\Framework\Validation\Attributes\Min;
+use App\Framework\Validation\Attributes\Max;
+use App\Framework\Validation\Attributes\Url;
+
+final class MetaRequest
+{
+    #[MaxLength(255)]
+    public ?string $routePattern = null;
+
+    #[MaxLength(100)]
+    public ?string $entityType = null;
+
+    #[Min(1)]
+    public ?int $entityId = null;
+
+    #[Required]
+    #[MaxLength(255)]
+    public ?string $title = null;
+
+    #[MaxLength(500)]
+    public ?string $description = null;
+
+    public ?array $keywords = null;
+
+    #[MaxLength(255)]
+    public ?string $ogTitle = null;
+
+    #[MaxLength(500)]
+    public ?string $ogDescription = null;
+
+    #[Url]
+    #[MaxLength(500)]
+    public ?string $ogImage = null;
+
+    #[MaxLength(50)]
+    public ?string $ogType = null;
+
+    #[MaxLength(50)]
+    public ?string $twitterCard = null;
+
+    #[MaxLength(100)]
+    public ?string $twitterSite = null;
+
+    #[Url]
+    #[MaxLength(500)]
+    public ?string $canonical = null;
+
+    public ?array $customMeta = null;
+
+    #[Min(0)]
+    #[Max(999)]
+    public int $priority = 0;
+
+    public bool $active = true;
+
+    public function getKeywordsAsArray(): ?array
+    {
+        if ($this->keywords === null) {
+            return null;
+        }
+
+        if (is_array($this->keywords)) {
+            return $this->keywords;
+        }
+
+        if (is_string($this->keywords)) {
+            return array_filter(array_map('trim', explode(',', $this->keywords)));
+        }
+
+        return null;
+    }
+}
diff --git a/src/Domain/Meta/Interface/MetaAware.php b/src/Domain/Meta/Interface/MetaAware.php
new file mode 100644
index 00000000..25cc891f
--- /dev/null
+++ b/src/Domain/Meta/Interface/MetaAware.php
@@ -0,0 +1,41 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Domain\Meta\Interface;
+
+/**
+ * Interface für Domain-Objekte, die ihre eigenen Meta-Daten bereitstellen können
+ */
+interface MetaAware
+{
+    /**
+     * Gibt den Meta-Titel zurück
+     */
+    public function getMetaTitle(): string;
+
+    /**
+     * Gibt die Meta-Beschreibung zurück
+     */
+    public function getMetaDescription(): string;
+
+    /**
+     * Gibt Meta-Keywords zurück
+     */
+    public function getMetaKeywords(): array;
+
+    /**
+     * Gibt das Open Graph Bild zurück
+     */
+    public function getOgImage(): ?string;
+
+    /**
+     * Gibt den Open Graph Typ zurück (optional)
+     */
+    public function getOgType(): string;
+
+    /**
+     * Gibt die kanonische URL zurück (optional)
+     */
+    public function getCanonicalUrl(): ?string;
+}
diff --git a/src/Domain/Meta/README.md b/src/Domain/Meta/README.md
new file mode 100644
index 00000000..e8f621e6
--- /dev/null
+++ b/src/Domain/Meta/README.md
@@ -0,0 +1,18 @@
+# Meta-Daten Modul
+
+Dieses Modul bietet eine flexible und mächtige Lösung für die Verwaltung von HTML-Meta-Daten in Ihrer Anwendung.
+
+## Features
+
+- **Datenbankbasierte Meta-Verwaltung** - Alle Meta-Daten werden in der Datenbank gespeichert
+- **Route-basierte Meta-Daten** - Meta-Daten können spezifischen Routen zugeordnet werden
+- **Entity-basierte Meta-Daten** - Meta-Daten für spezifische Domain-Objekte
+- **Template-System** - Dynamische Meta-Daten mit Platzhaltern
+- **Automatische Injection** - Meta-Tags werden automatisch in HTML-Responses eingefügt
+- **Admin-Interface** - RESTful API für die Verwaltung
+- **Cache-Unterstützung** - Performance-Optimierung durch Caching
+- **Prioritäts-System** - Kontrolle über Meta-Daten Präzedenz
+
+## Installation
+
+1. **Datenbank-Migration ausführen:**
diff --git a/src/Domain/Meta/Repository/DatabaseMetaRepository.php b/src/Domain/Meta/Repository/DatabaseMetaRepository.php
new file mode 100644
index 00000000..17383e76
--- /dev/null
+++ b/src/Domain/Meta/Repository/DatabaseMetaRepository.php
@@ -0,0 +1,274 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Domain\Meta\Repository;
+
+use App\Domain\Meta\Entity\MetaEntry;
+use App\Domain\Meta\ValueObject\MetaData;
+use PDO;
+
+final readonly class DatabaseMetaRepository implements MetaRepositoryInterface
+{
+    public function __construct(
+        private PDO $pdo
+    ) {}
+
+    public function findByRoute(string $route): ?MetaEntry
+    {
+        $entries = $this->findAllByRoute($route);
+        return $entries[0] ?? null;
+    }
+
+    public function findByEntity(string $entityType, int $entityId): ?MetaEntry
+    {
+        $stmt = $this->pdo->prepare('
+            SELECT * FROM meta_entries
+            WHERE entity_type = ? AND entity_id = ? AND active = 1
+            ORDER BY priority DESC
+            LIMIT 1
+        ');
+
+        $stmt->execute([$entityType, $entityId]);
+
+        if ($row = $stmt->fetch(PDO::FETCH_ASSOC)) {
+            return $this->hydrateFromRow($row);
+        }
+
+        return null;
+    }
+
+    public function findAllByRoute(string $route): array
+    {
+        $stmt = $this->pdo->prepare('
+            SELECT * FROM meta_entries
+            WHERE route_pattern IS NOT NULL
+            AND active = 1
+            ORDER BY priority DESC, LENGTH(route_pattern) DESC
+        ');
+
+        $stmt->execute();
+        $entries = [];
+
+        while ($row = $stmt->fetch(PDO::FETCH_ASSOC)) {
+            $entry = $this->hydrateFromRow($row);
+            if ($entry->matchesRoute($route)) {
+                $entries[] = $entry;
+            }
+        }
+
+        return $entries;
+    }
+
+    public function save(MetaEntry $entry): MetaEntry
+    {
+        if ($entry->id === null) {
+            return $this->insert($entry);
+        } else {
+            return $this->update($entry);
+        }
+    }
+
+    private function insert(MetaEntry $entry): MetaEntry
+    {
+        $stmt = $this->pdo->prepare('
+            INSERT INTO meta_entries (
+                route_pattern, entity_type, entity_id,
+                title, description, keywords, og_title, og_description,
+                og_image, og_type, twitter_card, twitter_site,
+                canonical, custom_meta, priority, active, created_at, updated_at
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        ');
+
+        $metaArray = $entry->metaData->toArray();
+
+        $stmt->execute([
+            $entry->routePattern,
+            $entry->entityType,
+            $entry->entityId,
+            $metaArray['title'] ?? null,
+            $metaArray['description'] ?? null,
+            $metaArray['keywords'] ?? null,
+            $metaArray['og_title'] ?? null,
+            $metaArray['og_description'] ?? null,
+            $metaArray['og_image'] ?? null,
+            $metaArray['og_type'] ?? null,
+            $metaArray['twitter_card'] ?? null,
+            $metaArray['twitter_site'] ?? null,
+            $metaArray['canonical'] ?? null,
+            $metaArray['custom_meta'] ?? null,
+            $entry->priority,
+            $entry->active ? 1 : 0,
+            $entry->createdAt->format('Y-m-d H:i:s'),
+            $entry->updatedAt->format('Y-m-d H:i:s'),
+        ]);
+
+        $entry->id = (int) $this->pdo->lastInsertId();
+        return $entry;
+    }
+
+    private function update(MetaEntry $entry): MetaEntry
+    {
+        $stmt = $this->pdo->prepare('
+            UPDATE meta_entries SET
+                route_pattern = ?, entity_type = ?, entity_id = ?,
+                title = ?, description = ?, keywords = ?, og_title = ?,
+                og_description = ?, og_image = ?, og_type = ?, twitter_card = ?,
+                twitter_site = ?, canonical = ?, custom_meta = ?,
+                priority = ?, active = ?, updated_at = ?
+            WHERE id = ?
+        ');
+
+        $metaArray = $entry->metaData->toArray();
+        $entry->updatedAt = new \DateTimeImmutable();
+
+        $stmt->execute([
+            $entry->routePattern,
+            $entry->entityType,
+            $entry->entityId,
+            $metaArray['title'] ?? null,
+            $metaArray['description'] ?? null,
+            $metaArray['keywords'] ?? null,
+            $metaArray['og_title'] ?? null,
+            $metaArray['og_description'] ?? null,
+            $metaArray['og_image'] ?? null,
+            $metaArray['og_type'] ?? null,
+            $metaArray['twitter_card'] ?? null,
+            $metaArray['twitter_site'] ?? null,
+            $metaArray['canonical'] ?? null,
+            $metaArray['custom_meta'] ?? null,
+            $entry->priority,
+            $entry->active ? 1 : 0,
+            $entry->updatedAt->format('Y-m-d H:i:s'),
+            $entry->id,
+        ]);
+
+        return $entry;
+    }
+
+    public function delete(int $id): bool
+    {
+        $stmt = $this->pdo->prepare('DELETE FROM meta_entries WHERE id = ?');
+        $stmt->execute([$id]);
+        return $stmt->rowCount() > 0;
+    }
+
+    public function findById(int $id): ?MetaEntry
+    {
+        $stmt = $this->pdo->prepare('SELECT * FROM meta_entries WHERE id = ?');
+        $stmt->execute([$id]);
+
+        if ($row = $stmt->fetch(PDO::FETCH_ASSOC)) {
+            return $this->hydrateFromRow($row);
+        }
+
+        return null;
+    }
+
+    public function findAll(int $limit = 50, int $offset = 0): array
+    {
+        $stmt = $this->pdo->prepare('
+            SELECT * FROM meta_entries
+            ORDER BY created_at DESC
+            LIMIT ? OFFSET ?
+        ');
+
+        $stmt->execute([$limit, $offset]);
+        $entries = [];
+
+        while ($row = $stmt->fetch(PDO::FETCH_ASSOC)) {
+            $entries[] = $this->hydrateFromRow($row);
+        }
+
+        return $entries;
+    }
+
+    public function search(string $query, int $limit = 50): array
+    {
+        $stmt = $this->pdo->prepare('
+            SELECT * FROM meta_entries
+            WHERE route_pattern LIKE ?
+            OR title LIKE ?
+            OR description LIKE ?
+            ORDER BY created_at DESC
+            LIMIT ?
+        ');
+
+        $searchTerm = "%{$query}%";
+        $stmt->execute([$searchTerm, $searchTerm, $searchTerm, $limit]);
+        $entries = [];
+
+        while ($row = $stmt->fetch(PDO::FETCH_ASSOC)) {
+            $entries[] = $this->hydrateFromRow($row);
+        }
+
+        return $entries;
+    }
+
+    public function count(): int
+    {
+        $stmt = $this->pdo->query('SELECT COUNT(*) FROM meta_entries');
+        return (int) $stmt->fetchColumn();
+    }
+
+    public function routePatternExists(string $routePattern, ?int $excludeId = null): bool
+    {
+        $sql = 'SELECT COUNT(*) FROM meta_entries WHERE route_pattern = ?';
+        $params = [$routePattern];
+
+        if ($excludeId !== null) {
+            $sql .= ' AND id != ?';
+            $params[] = $excludeId;
+        }
+
+        $stmt = $this->pdo->prepare($sql);
+        $stmt->execute($params);
+
+        return (int) $stmt->fetchColumn() > 0;
+    }
+
+    public function entityMetaExists(string $entityType, int $entityId, ?int $excludeId = null): bool
+    {
+        $sql = 'SELECT COUNT(*) FROM meta_entries WHERE entity_type = ? AND entity_id = ?';
+        $params = [$entityType, $entityId];
+
+        if ($excludeId !== null) {
+            $sql .= ' AND id != ?';
+            $params[] = $excludeId;
+        }
+
+        $stmt = $this->pdo->prepare($sql);
+        $stmt->execute($params);
+
+        return (int) $stmt->fetchColumn() > 0;
+    }
+
+    private function hydrateFromRow(array $row): MetaEntry
+    {
+        $metaData = MetaData::fromArray([
+            'title' => $row['title'],
+            'description' => $row['description'],
+            'keywords' => $row['keywords'],
+            'og_title' => $row['og_title'],
+            'og_description' => $row['og_description'],
+            'og_image' => $row['og_image'],
+            'og_type' => $row['og_type'],
+            'twitter_card' => $row['twitter_card'],
+            'twitter_site' => $row['twitter_site'],
+            'canonical' => $row['canonical'],
+            'custom_meta' => $row['custom_meta'],
+        ]);
+
+        return new MetaEntry(
+            id: (int) $row['id'],
+            routePattern: $row['route_pattern'],
+            entityType: $row['entity_type'],
+            entityId: $row['entity_id'] ? (int) $row['entity_id'] : null,
+            metaData: $metaData,
+            priority: (int) $row['priority'],
+            active: (bool) $row['active'],
+            createdAt: new \DateTimeImmutable($row['created_at']),
+            updatedAt: new \DateTimeImmutable($row['updated_at']),
+        );
+    }
+}
diff --git a/src/Domain/Meta/Repository/MetaRepositoryInterface.php b/src/Domain/Meta/Repository/MetaRepositoryInterface.php
new file mode 100644
index 00000000..34aaf750
--- /dev/null
+++ b/src/Domain/Meta/Repository/MetaRepositoryInterface.php
@@ -0,0 +1,66 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Domain\Meta\Repository;
+
+use App\Domain\Meta\Entity\MetaEntry;
+use App\Domain\Meta\ValueObject\MetaData;
+
+interface MetaRepositoryInterface
+{
+    /**
+     * Findet Meta-Daten für eine Route
+     */
+    public function findByRoute(string $route): ?MetaEntry;
+
+    /**
+     * Findet Meta-Daten für eine Entity
+     */
+    public function findByEntity(string $entityType, int $entityId): ?MetaEntry;
+
+    /**
+     * Findet alle aktiven Meta-Einträge für eine Route (sortiert nach Priorität)
+     */
+    public function findAllByRoute(string $route): array;
+
+    /**
+     * Speichert einen Meta-Eintrag
+     */
+    public function save(MetaEntry $entry): MetaEntry;
+
+    /**
+     * Löscht einen Meta-Eintrag
+     */
+    public function delete(int $id): bool;
+
+    /**
+     * Findet einen Meta-Eintrag anhand der ID
+     */
+    public function findById(int $id): ?MetaEntry;
+
+    /**
+     * Findet alle Meta-Einträge (mit Paginierung)
+     */
+    public function findAll(int $limit = 50, int $offset = 0): array;
+
+    /**
+     * Sucht Meta-Einträge nach Pattern
+     */
+    public function search(string $query, int $limit = 50): array;
+
+    /**
+     * Zählt alle Meta-Einträge
+     */
+    public function count(): int;
+
+    /**
+     * Prüft ob ein Route-Pattern bereits existiert
+     */
+    public function routePatternExists(string $routePattern, ?int $excludeId = null): bool;
+
+    /**
+     * Prüft ob eine Entity bereits Meta-Daten hat
+     */
+    public function entityMetaExists(string $entityType, int $entityId, ?int $excludeId = null): bool;
+}
diff --git a/src/Domain/Meta/Service/MetaManager.php b/src/Domain/Meta/Service/MetaManager.php
new file mode 100644
index 00000000..c92f7c9e
--- /dev/null
+++ b/src/Domain/Meta/Service/MetaManager.php
@@ -0,0 +1,186 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Domain\Meta\Service;
+
+use App\Domain\Meta\Repository\MetaRepositoryInterface;
+use App\Domain\Meta\ValueObject\MetaData;
+use App\Framework\Cache\CacheInterface;
+use App\Framework\Http\Request;
+
+final readonly class MetaManager
+{
+    public function __construct(
+        private MetaRepositoryInterface $repository,
+        private ?CacheInterface $cache = null,
+        private ?MetaTemplateResolver $templateResolver = null,
+    ) {}
+
+    /**
+     * Löst Meta-Daten für einen Request auf
+     */
+    public function resolveForRequest(Request $request, array $context = []): MetaData
+    {
+        $route = $this->extractRoute($request);
+        $cacheKey = "meta:{$route}:" . md5(serialize($context));
+
+        // Cache-Check
+        if ($this->cache && ($cached = $this->cache->get($cacheKey))) {
+            return $cached;
+        }
+
+        $meta = new MetaData();
+
+        // 1. Route-basierte Meta-Daten
+        if ($routeMeta = $this->repository->findByRoute($route)) {
+            $meta = $meta->merge($routeMeta->metaData);
+        }
+
+        // 2. Entity-basierte Meta-Daten
+        if ($entityMeta = $this->resolveEntityMeta($request)) {
+            $meta = $meta->merge($entityMeta->metaData);
+        }
+
+        // 3. Template-Verarbeitung
+        if ($this->templateResolver && !empty($context)) {
+            $meta = $this->templateResolver->resolve($meta, $context);
+        }
+
+        // 4. Cache speichern
+        if ($this->cache) {
+            $this->cache->set($cacheKey, $meta, 3600);
+        }
+
+        return $meta;
+    }
+
+    /**
+     * Löst Meta-Daten für eine spezifische Route auf
+     */
+    public function resolveForRoute(string $route, array $context = []): MetaData
+    {
+        $meta = new MetaData();
+
+        if ($routeMeta = $this->repository->findByRoute($route)) {
+            $meta = $meta->merge($routeMeta->metaData);
+        }
+
+        if ($this->templateResolver && !empty($context)) {
+            $meta = $this->templateResolver->resolve($meta, $context);
+        }
+
+        return $meta;
+    }
+
+    /**
+     * Löst Meta-Daten für eine Entity auf
+     */
+    public function resolveForEntity(string $entityType, int $entityId, array $context = []): MetaData
+    {
+        $meta = new MetaData();
+
+        if ($entityMeta = $this->repository->findByEntity($entityType, $entityId)) {
+            $meta = $meta->merge($entityMeta->metaData);
+        }
+
+        if ($this->templateResolver && !empty($context)) {
+            $meta = $this->templateResolver->resolve($meta, $context);
+        }
+
+        return $meta;
+    }
+
+    /**
+     * Invalidiert den Cache für eine Route
+     */
+    public function invalidateCache(string $route): void
+    {
+        if (!$this->cache) {
+            return;
+        }
+
+        // Alle Cache-Keys für diese Route löschen
+        $pattern = "meta:{$route}:*";
+        $this->cache->deleteByPattern($pattern);
+    }
+
+    /**
+     * Invalidiert den gesamten Meta-Cache
+     */
+    public function invalidateAllCache(): void
+    {
+        if (!$this->cache) {
+            return;
+        }
+
+        $this->cache->deleteByPattern('meta:*');
+    }
+
+    private function extractRoute(Request $request): string
+    {
+        // Extrahiert die Route aus dem Request
+        $uri = $request->getUri();
+        $path = parse_url($uri, PHP_URL_PATH) ?: '/';
+
+        // Query-Parameter entfernen für einheitliche Cache-Keys
+        return rtrim($path, '/') ?: '/';
+    }
+
+    private function resolveEntityMeta(Request $request): ?\App\Domain\Meta\Entity\MetaEntry
+    {
+        // Versuche Entity-Typ und ID aus der Route zu extrahieren
+        $routeParams = $request->getRouteParameters() ?? [];
+
+        if (isset($routeParams['id'])) {
+            $entityType = $this->extractEntityTypeFromRoute($this->extractRoute($request));
+            if ($entityType) {
+                return $this->repository->findByEntity($entityType, (int)$routeParams['id']);
+            }
+        }
+
+        return null;
+    }
+
+    private function extractEntityTypeFromRoute(string $route): ?string
+    {
+        // Einfache Heuristik: /products/123 -> entityType = "product"
+        // /blog/456 -> entityType = "blog"
+        $parts = explode('/', trim($route, '/'));
+
+        if (count($parts) >= 2 && is_numeric($parts[1])) {
+            $entityType = rtrim($parts[0], 's'); // Plural zu Singular
+            return $entityType;
+        }
+
+        return null;
+    }
+
+    /**
+     * Erstellt Standard-Meta-Daten basierend auf dem Request
+     */
+    public function createDefaultMeta(Request $request): MetaData
+    {
+        $route = $this->extractRoute($request);
+        $title = $this->generateDefaultTitle($route);
+
+        return new MetaData(
+            title: $title,
+            description: "Seite: {$route}",
+            ogTitle: $title,
+            ogType: 'website',
+        );
+    }
+
+    private function generateDefaultTitle(string $route): string
+    {
+        if ($route === '/') {
+            return 'Startseite';
+        }
+
+        $parts = explode('/', trim($route, '/'));
+        $title = ucfirst(str_replace(['-', '_'], ' ', end($parts)));
+
+        return $title;
+    }
+}
diff --git a/src/Domain/Meta/Service/MetaTemplateResolver.php b/src/Domain/Meta/Service/MetaTemplateResolver.php
new file mode 100644
index 00000000..ee8a5db1
--- /dev/null
+++ b/src/Domain/Meta/Service/MetaTemplateResolver.php
@@ -0,0 +1,153 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Domain\Meta\Service;
+
+use App\Domain\Meta\ValueObject\MetaData;
+
+final readonly class MetaTemplateResolver
+{
+    /**
+     * Löst Templates in Meta-Daten auf
+     */
+    public function resolve(MetaData $meta, array $context): MetaData
+    {
+        return new MetaData(
+            title: $this->resolveTemplate($meta->title, $context),
+            description: $this->resolveTemplate($meta->description, $context),
+            keywords: $meta->keywords,
+            ogTitle: $this->resolveTemplate($meta->ogTitle, $context),
+            ogDescription: $this->resolveTemplate($meta->ogDescription, $context),
+            ogImage: $this->resolveTemplate($meta->ogImage, $context),
+            ogType: $meta->ogType,
+            twitterCard: $meta->twitterCard,
+            twitterSite: $meta->twitterSite,
+            canonical: $this->resolveTemplate($meta->canonical, $context),
+            customMeta: $this->resolveCustomMeta($meta->customMeta ?? [], $context),
+        );
+    }
+
+    private function resolveTemplate(?string $template, array $context): ?string
+    {
+        if ($template === null) {
+            return null;
+        }
+
+        // Unterstützt sowohl {variable} als auch {{variable}} Syntax
+        $template = preg_replace_callback('/\{\{?(\w+(?:\.\w+)*)\}?\}/', function($matches) use ($context) {
+            $key = $matches[1];
+            $value = $this->getNestedValue($context, $key);
+
+            return $value !== null ? (string) $value : $matches[0];
+        }, $template);
+
+        // Unterstützt einfache Funktionen: {upper:variable}, {lower:variable}
+        $template = preg_replace_callback('/\{(\w+):(\w+(?:\.\w+)*)\}/', function($matches) use ($context) {
+            $function = $matches[1];
+            $key = $matches[2];
+            $value = $this->getNestedValue($context, $key);
+
+            if ($value === null) {
+                return $matches[0];
+            }
+
+            return match($function) {
+                'upper' => strtoupper((string) $value),
+                'lower' => strtolower((string) $value),
+                'title' => ucwords((string) $value),
+                'truncate' => $this->truncate((string) $value, 160),
+                'strip_tags' => strip_tags((string) $value),
+                default => (string) $value,
+            };
+        }, $template);
+
+        return $template;
+    }
+
+    private function resolveCustomMeta(array $customMeta, array $context): array
+    {
+        $resolved = [];
+
+        foreach ($customMeta as $name => $content) {
+            $resolved[$name] = $this->resolveTemplate($content, $context);
+        }
+
+        return $resolved;
+    }
+
+    private function getNestedValue(array $data, string $key): mixed
+    {
+        $keys = explode('.', $key);
+        $value = $data;
+
+        foreach ($keys as $k) {
+            if (is_array($value) && isset($value[$k])) {
+                $value = $value[$k];
+            } elseif (is_object($value) && property_exists($value, $k)) {
+                $value = $value->$k;
+            } elseif (is_object($value) && method_exists($value, $k)) {
+                $value = $value->$k();
+            } elseif (is_object($value) && method_exists($value, 'get' . ucfirst($k))) {
+                $method = 'get' . ucfirst($k);
+                $value = $value->$method();
+            } else {
+                return null;
+            }
+        }
+
+        return $value;
+    }
+
+    private function truncate(string $text, int $length, string $suffix = '...'): string
+    {
+        if (mb_strlen($text) <= $length) {
+            return $text;
+        }
+
+        return mb_substr($text, 0, $length - mb_strlen($suffix)) . $suffix;
+    }
+
+    /**
+     * Validiert Template-Syntax
+     */
+    public function validateTemplate(string $template): array
+    {
+        $errors = [];
+
+        // Prüfe auf ungeschlossene Klammern
+        $openBraces = substr_count($template, '{');
+        $closeBraces = substr_count($template, '}');
+
+        if ($openBraces !== $closeBraces) {
+            $errors[] = 'Ungleiche Anzahl von öffnenden und schließenden Klammern';
+        }
+
+        // Prüfe auf gültige Template-Syntax
+        preg_match_all('/\{([^}]+)\}/', $template, $matches);
+
+        foreach ($matches[1] as $placeholder) {
+            if (!preg_match('/^(\w+:)?[\w.]+$/', $placeholder)) {
+                $errors[] = "Ungültige Template-Syntax: {{$placeholder}}";
+            }
+        }
+
+        return $errors;
+    }
+
+    /**
+     * Extrahiert alle Platzhalter aus einem Template
+     */
+    public function extractPlaceholders(string $template): array
+    {
+        preg_match_all('/\{\{?(\w+(?:\.\w+)*)\}?\}/', $template, $matches);
+        preg_match_all('/\{(\w+):(\w+(?:\.\w+)*)\}/', $template, $functionMatches);
+
+        $placeholders = array_unique(array_merge(
+            $matches[1] ?? [],
+            $functionMatches[2] ?? []
+        ));
+
+        return $placeholders;
+    }
+}
diff --git a/src/Domain/Meta/ValueObject/MetaData.php b/src/Domain/Meta/ValueObject/MetaData.php
new file mode 100644
index 00000000..b943aaf4
--- /dev/null
+++ b/src/Domain/Meta/ValueObject/MetaData.php
@@ -0,0 +1,149 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Domain\Meta\ValueObject;
+
+readonly class MetaData
+{
+    public function __construct(
+        public ?string $title = null,
+        public ?string $description = null,
+        public ?array $keywords = null,
+        public ?string $ogTitle = null,
+        public ?string $ogDescription = null,
+        public ?string $ogImage = null,
+        public ?string $ogType = null,
+        public ?string $twitterCard = null,
+        public ?string $twitterSite = null,
+        public ?string $canonical = null,
+        public ?array $customMeta = null,
+    ) {}
+
+    public static function fromArray(array $data): self
+    {
+        return new self(
+            title: $data['title'] ?? null,
+            description: $data['description'] ?? null,
+            keywords: isset($data['keywords']) ? (is_array($data['keywords']) ? $data['keywords'] : explode(',', $data['keywords'])) : null,
+            ogTitle: $data['og_title'] ?? null,
+            ogDescription: $data['og_description'] ?? null,
+            ogImage: $data['og_image'] ?? null,
+            ogType: $data['og_type'] ?? null,
+            twitterCard: $data['twitter_card'] ?? null,
+            twitterSite: $data['twitter_site'] ?? null,
+            canonical: $data['canonical'] ?? null,
+            customMeta: isset($data['custom_meta']) ? (is_array($data['custom_meta']) ? $data['custom_meta'] : json_decode($data['custom_meta'], true)) : null,
+        );
+    }
+
+    public function merge(MetaData $other): self
+    {
+        return new self(
+            title: $other->title ?? $this->title,
+            description: $other->description ?? $this->description,
+            keywords: $other->keywords ?? $this->keywords,
+            ogTitle: $other->ogTitle ?? $this->ogTitle,
+            ogDescription: $other->ogDescription ?? $this->ogDescription,
+            ogImage: $other->ogImage ?? $this->ogImage,
+            ogType: $other->ogType ?? $this->ogType,
+            twitterCard: $other->twitterCard ?? $this->twitterCard,
+            twitterSite: $other->twitterSite ?? $this->twitterSite,
+            canonical: $other->canonical ?? $this->canonical,
+            customMeta: array_merge($this->customMeta ?? [], $other->customMeta ?? []),
+        );
+    }
+
+    public function toArray(): array
+    {
+        return array_filter([
+            'title' => $this->title,
+            'description' => $this->description,
+            'keywords' => $this->keywords ? implode(',', $this->keywords) : null,
+            'og_title' => $this->ogTitle,
+            'og_description' => $this->ogDescription,
+            'og_image' => $this->ogImage,
+            'og_type' => $this->ogType,
+            'twitter_card' => $this->twitterCard,
+            'twitter_site' => $this->twitterSite,
+            'canonical' => $this->canonical,
+            'custom_meta' => $this->customMeta ? json_encode($this->customMeta) : null,
+        ], fn($value) => $value !== null);
+    }
+
+    public function isEmpty(): bool
+    {
+        return $this->title === null
+            && $this->description === null
+            && empty($this->keywords)
+            && $this->ogTitle === null
+            && $this->ogDescription === null
+            && $this->ogImage === null
+            && empty($this->customMeta);
+    }
+
+    public function render(): string
+    {
+        if ($this->isEmpty()) {
+            return '';
+        }
+
+        $html = [];
+
+        // Basic Meta Tags
+        if ($this->title) {
+            $html[] = '<title>' . htmlspecialchars($this->title, ENT_QUOTES, 'UTF-8') . '</title>';
+        }
+
+        if ($this->description) {
+            $html[] = '<meta name="description" content="' . htmlspecialchars($this->description, ENT_QUOTES, 'UTF-8') . '">';
+        }
+
+        if ($this->keywords) {
+            $html[] = '<meta name="keywords" content="' . htmlspecialchars(implode(', ', $this->keywords), ENT_QUOTES, 'UTF-8') . '">';
+        }
+
+        if ($this->canonical) {
+            $html[] = '<link rel="canonical" href="' . htmlspecialchars($this->canonical, ENT_QUOTES, 'UTF-8') . '">';
+        }
+
+        // Open Graph
+        if ($this->ogTitle) {
+            $html[] = '<meta property="og:title" content="' . htmlspecialchars($this->ogTitle, ENT_QUOTES, 'UTF-8') . '">';
+        }
+
+        if ($this->ogDescription) {
+            $html[] = '<meta property="og:description" content="' . htmlspecialchars($this->ogDescription, ENT_QUOTES, 'UTF-8') . '">';
+        }
+
+        if ($this->ogImage) {
+            $html[] = '<meta property="og:image" content="' . htmlspecialchars($this->ogImage, ENT_QUOTES, 'UTF-8') . '">';
+        }
+
+        if ($this->ogType) {
+            $html[] = '<meta property="og:type" content="' . htmlspecialchars($this->ogType, ENT_QUOTES, 'UTF-8') . '">';
+        }
+
+        // Twitter
+        if ($this->twitterCard) {
+            $html[] = '<meta name="twitter:card" content="' . htmlspecialchars($this->twitterCard, ENT_QUOTES, 'UTF-8') . '">';
+        }
+
+        if ($this->twitterSite) {
+            $html[] = '<meta name="twitter:site" content="' . htmlspecialchars($this->twitterSite, ENT_QUOTES, 'UTF-8') . '">';
+        }
+
+        // Custom Meta
+        if ($this->customMeta) {
+            foreach ($this->customMeta as $name => $content) {
+                if (str_starts_with($name, 'og:')) {
+                    $html[] = '<meta property="' . htmlspecialchars($name, ENT_QUOTES, 'UTF-8') . '" content="' . htmlspecialchars($content, ENT_QUOTES, 'UTF-8') . '">';
+                } else {
+                    $html[] = '<meta name="' . htmlspecialchars($name, ENT_QUOTES, 'UTF-8') . '" content="' . htmlspecialchars($content, ENT_QUOTES, 'UTF-8') . '">';
+                }
+            }
+        }
+
+        return implode("\n", $html);
+    }
+}
diff --git a/src/Domain/QrCode/Exception/QrCodeException.php b/src/Domain/QrCode/Exception/QrCodeException.php
new file mode 100644
index 00000000..7ac73e61
--- /dev/null
+++ b/src/Domain/QrCode/Exception/QrCodeException.php
@@ -0,0 +1,11 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Domain\QrCode\Exception;
+
+use Exception;
+
+class QrCodeException extends Exception
+{
+}
diff --git a/src/Domain/QrCode/Pattern/AlignmentPattern.php b/src/Domain/QrCode/Pattern/AlignmentPattern.php
new file mode 100644
index 00000000..3bddf919
--- /dev/null
+++ b/src/Domain/QrCode/Pattern/AlignmentPattern.php
@@ -0,0 +1,84 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Domain\QrCode\Pattern;
+
+use App\Domain\QrCode\ValueObject\Position;
+
+class AlignmentPattern implements PatternInterface
+{
+    // Tabelle der Ausrichtungsmuster-Positionen für Versionen 1-40
+    private const POSITIONS = [
+        1 => [],
+        2 => [6, 18],
+        3 => [6, 22],
+        4 => [6, 26],
+        5 => [6, 30],
+        6 => [6, 34],
+        7 => [6, 22, 38],
+        8 => [6, 24, 42],
+        9 => [6, 26, 46],
+        10 => [6, 28, 50],
+        // ... weitere Versionen hier hinzufügen
+    ];
+
+    public function __construct(
+        private readonly int $version
+    ) {
+    }
+
+    public function apply(array &$matrix, int $size): void
+    {
+        if ($this->version === 1) {
+            return; // Version 1 hat keine Ausrichtungsmuster
+        }
+
+        $positions = self::POSITIONS[$this->version] ?? $this->calculatePositions($size);
+
+        foreach ($positions as $centerRow) {
+            foreach ($positions as $centerCol) {
+                if ($this->overlapsWithFinderPattern($centerRow, $centerCol, $size)) {
+                    continue;
+                }
+
+                $this->applyPattern($matrix, $centerRow, $centerCol, $size);
+            }
+        }
+    }
+
+    private function applyPattern(array &$matrix, int $centerRow, int $centerCol, int $size): void
+    {
+        // 5x5 Ausrichtungsmuster
+        for ($r = -2; $r <= 2; $r++) {
+            for ($c = -2; $c <= 2; $c++) {
+                $position = new Position($centerRow + $r, $centerCol + $c);
+
+                if ($position->isWithinBounds($size)) {
+                    // Äußerer Rand oder Mittelpunkt
+                    $isBlack = abs($r) === 2 || abs($c) === 2 || ($r === 0 && $c === 0);
+                    $matrix[$centerRow + $r][$centerCol + $c] = $isBlack;
+                }
+            }
+        }
+    }
+
+    private function overlapsWithFinderPattern(int $row, int $col, int $size): bool
+    {
+        return ($row <= 8 && $col <= 8) ||
+               ($row <= 8 && $col >= $size - 9) ||
+               ($row >= $size - 9 && $col <= 8);
+    }
+
+    private function calculatePositions(int $size): array
+    {
+        // Vereinfachte Berechnung für fehlende Versionen
+        $positions = [6];
+
+        if ($size >= 25) { // Ab Version 2
+            $positions[] = $size - 7;
+        }
+
+        return $positions;
+    }
+}
diff --git a/src/Domain/QrCode/Pattern/AlignmentPatternTable.php b/src/Domain/QrCode/Pattern/AlignmentPatternTable.php
new file mode 100644
index 00000000..1b6db2a9
--- /dev/null
+++ b/src/Domain/QrCode/Pattern/AlignmentPatternTable.php
@@ -0,0 +1,73 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Domain\QrCode\Pattern;
+
+/**
+ * Stellt die Positionstabelle für die Ausrichtungsmuster (Alignment Patterns) zur Verfügung
+ */
+class AlignmentPatternTable
+{
+    /**
+     * Tabelle der Alignment Pattern Positionen für alle QR-Code-Versionen
+     * Werte entsprechen den Mittelpunkten der Alignment Pattern im QR-Code
+     */
+    public const POSITIONS = [
+        1 => [], // Version 1 hat keine Alignment Patterns
+        2 => [6, 18],
+        3 => [6, 22],
+        4 => [6, 26],
+        5 => [6, 30],
+        6 => [6, 34],
+        7 => [6, 22, 38],
+        8 => [6, 24, 42],
+        9 => [6, 26, 46],
+        10 => [6, 28, 50],
+        11 => [6, 30, 54],
+        12 => [6, 32, 58],
+        13 => [6, 34, 62],
+        14 => [6, 26, 46, 66],
+        15 => [6, 26, 48, 70],
+        16 => [6, 26, 50, 74],
+        17 => [6, 30, 54, 78],
+        18 => [6, 30, 56, 82],
+        19 => [6, 30, 58, 86],
+        20 => [6, 34, 62, 90],
+        21 => [6, 28, 50, 72, 94],
+        22 => [6, 26, 50, 74, 98],
+        23 => [6, 30, 54, 78, 102],
+        24 => [6, 28, 54, 80, 106],
+        25 => [6, 32, 58, 84, 110],
+        26 => [6, 30, 58, 86, 114],
+        27 => [6, 34, 62, 90, 118],
+        28 => [6, 26, 50, 74, 98, 122],
+        29 => [6, 30, 54, 78, 102, 126],
+        30 => [6, 26, 52, 78, 104, 130],
+        31 => [6, 30, 56, 82, 108, 134],
+        32 => [6, 34, 60, 86, 112, 138],
+        33 => [6, 30, 58, 86, 114, 142],
+        34 => [6, 34, 62, 90, 118, 146],
+        35 => [6, 30, 54, 78, 102, 126, 150],
+        36 => [6, 24, 50, 76, 102, 128, 154],
+        37 => [6, 28, 54, 80, 106, 132, 158],
+        38 => [6, 32, 58, 84, 110, 136, 162],
+        39 => [6, 26, 54, 82, 110, 138, 166],
+        40 => [6, 30, 58, 86, 114, 142, 170],
+    ];
+
+    /**
+     * Gibt die Alignment Pattern Positionen für die angegebene QR-Code-Version zurück
+     *
+     * @param int $version QR-Code-Version (1-40)
+     * @return array Array mit den Positionen der Alignment Patterns
+     */
+    public static function getPositions(int $version): array
+    {
+        if ($version < 1 || $version > 40) {
+            return [];
+        }
+
+        return self::POSITIONS[$version];
+    }
+}
diff --git a/src/Domain/QrCode/Pattern/DarkModulePattern.php b/src/Domain/QrCode/Pattern/DarkModulePattern.php
new file mode 100644
index 00000000..c5f4d4a5
--- /dev/null
+++ b/src/Domain/QrCode/Pattern/DarkModulePattern.php
@@ -0,0 +1,24 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Domain\QrCode\Pattern;
+
+class DarkModulePattern implements PatternInterface
+{
+    public function __construct(
+        private readonly int $version
+    ) {
+    }
+
+    public function apply(array &$matrix, int $size): void
+    {
+        // Für Version 1 muss das Dark Module bei (8, 13) sein
+        if ($this->version === 1) {
+            $matrix[8][13] = true;
+        } else {
+            // Für andere Versionen: Position (4V+9, 8)
+            $matrix[(4 * $this->version) + 9][8] = true;
+        }
+    }
+}
diff --git a/src/Domain/QrCode/Pattern/FinderPattern.php b/src/Domain/QrCode/Pattern/FinderPattern.php
new file mode 100644
index 00000000..3ed2c72c
--- /dev/null
+++ b/src/Domain/QrCode/Pattern/FinderPattern.php
@@ -0,0 +1,69 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Domain\QrCode\Pattern;
+
+use App\Domain\QrCode\ValueObject\Position;
+
+class FinderPattern implements PatternInterface
+{
+    public function __construct(
+        private readonly Position $position
+    ) {
+    }
+
+    public function apply(array &$matrix, int $size): void
+    {
+        $row = $this->position->getRow();
+        $col = $this->position->getColumn();
+
+        // 7x7 Finder Pattern
+        for ($i = 0; $i < 7; $i++) {
+            for ($j = 0; $j < 7; $j++) {
+                // Äußerer Rand oder inneres Quadrat
+                $isBlack = ($i === 0 || $i === 6 || $j === 0 || $j === 6) ||
+                           ($i >= 2 && $i <= 4 && $j >= 2 && $j <= 4);
+
+                $position = new Position($row + $i, $col + $j);
+                if ($position->isWithinBounds($size)) {
+                    $matrix[$row + $i][$col + $j] = $isBlack;
+                }
+            }
+        }
+
+        // Weißer Separator um das Finder Pattern
+        $this->applySeparator($matrix, $size);
+    }
+
+    private function applySeparator(array &$matrix, int $size): void
+    {
+        $row = $this->position->getRow();
+        $col = $this->position->getColumn();
+
+        // Horizontaler Separator unten
+        for ($j = 0; $j < 8; $j++) {
+            $position = new Position($row + 7, $col + $j);
+            if ($position->isWithinBounds($size)) {
+                $matrix[$row + 7][$col + $j] = false;
+            }
+        }
+
+        // Vertikaler Separator rechts
+        for ($i = 0; $i < 8; $i++) {
+            $position = new Position($row + $i, $col + 7);
+            if ($position->isWithinBounds($size)) {
+                $matrix[$row + $i][$col + 7] = false;
+            }
+        }
+    }
+
+    public static function createAll(int $size): array
+    {
+        return [
+            new self(new Position(0, 0)),                // Oben links
+            new self(new Position(0, $size - 7)),        // Oben rechts
+            new self(new Position($size - 7, 0))         // Unten links
+        ];
+    }
+}
diff --git a/src/Domain/QrCode/Pattern/FormatInfoPattern.php b/src/Domain/QrCode/Pattern/FormatInfoPattern.php
new file mode 100644
index 00000000..60449e71
--- /dev/null
+++ b/src/Domain/QrCode/Pattern/FormatInfoPattern.php
@@ -0,0 +1,92 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Domain\QrCode\Pattern;
+
+use App\Domain\QrCode\ValueObject\ErrorCorrectionLevel;
+
+class FormatInfoPattern implements PatternInterface
+{
+    // Format-Strings für verschiedene Error Correction Levels und Masken
+    private const FORMAT_STRINGS = [
+        'L' => [
+            0 => '111011111000100',
+            1 => '111001011110011',
+            2 => '111110110101010',
+            3 => '111100010011101',
+            4 => '110011000101111',
+            5 => '110001100011000',
+            6 => '110110001000001',
+            7 => '110100101110110',
+        ],
+        'M' => [
+            0 => '101010000010010',
+            1 => '101000100100101',
+            2 => '101111001111100',
+            3 => '101101101001011',
+            4 => '100010111111001',
+            5 => '100000011001110',
+            6 => '100111110010111',
+            7 => '100101010100000',
+        ],
+        'Q' => [
+            0 => '011010101011111',
+            1 => '011000001101000',
+            2 => '011111100110001',
+            3 => '011101000000110',
+            4 => '010010010110100',
+            5 => '010000110000011',
+            6 => '010111011011010',
+            7 => '010101111101101',
+        ],
+        'H' => [
+            0 => '001011010001001',
+            1 => '001001110111110',
+            2 => '001110011100111',
+            3 => '001100111010000',
+            4 => '000011101100010',
+            5 => '000001001010101',
+            6 => '000110100001100',
+            7 => '000100000111011',
+        ],
+    ];
+
+    public function __construct(
+        private readonly ErrorCorrectionLevel $level,
+        private readonly int $maskPattern
+    ) {
+    }
+
+    public function apply(array &$matrix, int $size): void
+    {
+        $formatString = self::FORMAT_STRINGS[$this->level->name][$this->maskPattern];
+
+        // Format-Info um das obere linke Finder-Pattern
+        for ($i = 0; $i < 15; $i++) {
+            $bit = $formatString[$i] === '1';
+
+            // Format-Info horizontal
+            if ($i < 6) {
+                $matrix[8][$i] = $bit;
+            } elseif ($i < 8) {
+                $matrix[8][$i + 1] = $bit;
+            } elseif ($i === 8) {
+                $matrix[7][8] = $bit;
+            } else {
+                $matrix[14 - $i][8] = $bit;
+            }
+
+            // Format-Info vertikal
+            if ($i < 8) {
+                $matrix[$size - 1 - $i][8] = $bit;
+            } else {
+                $matrix[8][$size - 15 + $i] = $bit;
+            }
+        }
+
+        // Für Version 1 muss das Dark Module bei (8, 13) sein
+        // Dies ist für QR-Code-Scanner wichtig zur Orientierung
+        $matrix[8][13] = true;
+    }
+}
diff --git a/src/Domain/QrCode/Pattern/FormatInfoTable.php b/src/Domain/QrCode/Pattern/FormatInfoTable.php
new file mode 100644
index 00000000..9145168a
--- /dev/null
+++ b/src/Domain/QrCode/Pattern/FormatInfoTable.php
@@ -0,0 +1,75 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Domain\QrCode\Pattern;
+
+/**
+ * Stellt die Format-Information für QR-Codes bereit
+ */
+class FormatInfoTable
+{
+    /**
+     * Format-Information BCH-codiert (15 Bits)
+     * Schlüssel: [EC-Level][Maskenmuster] = 15-Bit BCH-codierte Formatinformation
+     */
+    public const FORMAT_INFO = [
+        'L' => [
+            0 => 0b111011111000100,
+            1 => 0b111001011110011,
+            2 => 0b111110110101010,
+            3 => 0b111100010011101,
+            4 => 0b110011000101111,
+            5 => 0b110001100011000,
+            6 => 0b110110001000001,
+            7 => 0b110100101110110,
+        ],
+        'M' => [
+            0 => 0b101010000010010,
+            1 => 0b101000100100101,
+            2 => 0b101111001111100,
+            3 => 0b101101101001011,
+            4 => 0b100010111111001,
+            5 => 0b100000011001110,
+            6 => 0b100111110010111,
+            7 => 0b100101010100000,
+        ],
+        'Q' => [
+            0 => 0b011010101011111,
+            1 => 0b011000001101000,
+            2 => 0b011111100110001,
+            3 => 0b011101000000110,
+            4 => 0b010010010110100,
+            5 => 0b010000110000011,
+            6 => 0b010111011011010,
+            7 => 0b010101111101101,
+        ],
+        'H' => [
+            0 => 0b001011010001001,
+            1 => 0b001001110111110,
+            2 => 0b001110011100111,
+            3 => 0b001100111010000,
+            4 => 0b000011101100010,
+            5 => 0b000001001010101,
+            6 => 0b000110100001100,
+            7 => 0b000100000111011,
+        ],
+    ];
+
+    /**
+     * Liefert die Formatinformation für das angegebene Error-Correction-Level und Maskenmuster
+     *
+     * @param string $ecLevel Error Correction Level (L, M, Q oder H)
+     * @param int $maskPattern Maskenmuster (0-7)
+     * @return int 15-Bit-Formatinformation
+     */
+    public static function getFormatInfo(string $ecLevel, int $maskPattern): int
+    {
+        if (!isset(self::FORMAT_INFO[$ecLevel]) || !isset(self::FORMAT_INFO[$ecLevel][$maskPattern])) {
+            // Fallback: L, Maske 0
+            return self::FORMAT_INFO['L'][0];
+        }
+
+        return self::FORMAT_INFO[$ecLevel][$maskPattern];
+    }
+}
diff --git a/src/Domain/QrCode/Pattern/PatternInterface.php b/src/Domain/QrCode/Pattern/PatternInterface.php
new file mode 100644
index 00000000..f9e0c098
--- /dev/null
+++ b/src/Domain/QrCode/Pattern/PatternInterface.php
@@ -0,0 +1,13 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Domain\QrCode\Pattern;
+
+interface PatternInterface
+{
+    /**
+     * Wendet das Muster auf die übergebene Matrix an
+     */
+    public function apply(array &$matrix, int $size): void;
+}
diff --git a/src/Domain/QrCode/Pattern/TimingPattern.php b/src/Domain/QrCode/Pattern/TimingPattern.php
new file mode 100644
index 00000000..8e6021c6
--- /dev/null
+++ b/src/Domain/QrCode/Pattern/TimingPattern.php
@@ -0,0 +1,23 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Domain\QrCode\Pattern;
+
+use App\Domain\QrCode\ValueObject\Position;
+
+class TimingPattern implements PatternInterface
+{
+    public function apply(array &$matrix, int $size): void
+    {
+        // Horizontales Timing Pattern
+        for ($i = 0; $i < $size; $i++) {
+            $matrix[6][$i] = ($i % 2 === 0);
+        }
+
+        // Vertikales Timing Pattern
+        for ($i = 0; $i < $size; $i++) {
+            $matrix[$i][6] = ($i % 2 === 0);
+        }
+    }
+}
diff --git a/src/Domain/QrCode/Pattern/VersionInfoPattern.php b/src/Domain/QrCode/Pattern/VersionInfoPattern.php
new file mode 100644
index 00000000..cb33d17b
--- /dev/null
+++ b/src/Domain/QrCode/Pattern/VersionInfoPattern.php
@@ -0,0 +1,119 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Domain\QrCode\Pattern;
+
+/**
+ * Implementiert das Version Information Pattern für QR-Codes ab Version 7
+ */
+class VersionInfoPattern implements PatternInterface
+{
+    /**
+     * Lookup-Tabelle für die Version-Information (BCH-kodiert)
+     * Diese 18-Bit-Werte enthalten die Versionsinformation mit Fehlerkorrektur
+     */
+    private const VERSION_INFO = [
+        7 => 0b000111110010010100,
+        8 => 0b001000010110111100,
+        9 => 0b001001101010011001,
+        10 => 0b001010010011010011,
+        11 => 0b001011101111110110,
+        12 => 0b001100011101100010,
+        13 => 0b001101100001000111,
+        14 => 0b001110011000001101,
+        15 => 0b001111100100101000,
+        16 => 0b010000101101111000,
+        17 => 0b010001010001011101,
+        18 => 0b010010101000010111,
+        19 => 0b010011010100110010,
+        20 => 0b010100100110100110,
+        21 => 0b010101011010000011,
+        22 => 0b010110100011001001,
+        23 => 0b010111011111101100,
+        24 => 0b011000111011000100,
+        25 => 0b011001000111100001,
+        26 => 0b011010111110101011,
+        27 => 0b011011000010001110,
+        28 => 0b011100110000011010,
+        29 => 0b011101001100111111,
+        30 => 0b011110110101110101,
+        31 => 0b011111001001010000,
+        32 => 0b100000100111010101,
+        33 => 0b100001011011110000,
+        34 => 0b100010100010111010,
+        35 => 0b100011011110011111,
+        36 => 0b100100101100001011,
+        37 => 0b100101010000101110,
+        38 => 0b100110101001100100,
+        39 => 0b100111010101000001,
+        40 => 0b101000110001101001,
+    ];
+
+    private int $version;
+
+    public function __construct(int $version)
+    {
+        $this->version = $version;
+    }
+
+    public function apply(array &$matrix, int $size): void
+    {
+        // Version Information Pattern nur für QR-Codes ab Version 7
+        if ($this->version < 7) {
+            return;
+        }
+
+        $versionInfo = self::VERSION_INFO[$this->version] ?? 0;
+
+        // Versionsinformation an zwei Positionen einfügen
+        $this->placeVersionInfo($matrix, $versionInfo); // Platziere oben rechts
+        $this->placeVersionInfoTransposed($matrix, $versionInfo); // Platziere unten links
+    }
+
+    /**
+     * Platziert die Versionsinformation unterhalb des Finder Patterns oben rechts
+     */
+    private function placeVersionInfo(array &$matrix, int $versionInfo): void
+    {
+        // Position: unterhalb des rechten oberen Finder Patterns
+        // 3 Zeilen x 6 Spalten = 18 Bits
+        $row = 0;
+        $col = $this->version * 4 + 6; // Rechts oben, die exakte Position hängt von der Version ab
+
+        // 18 Bits des Versionsinformationsblocks setzen
+        for ($i = 0; $i < 18; $i++) {
+            // Bit von rechts nach links extrahieren (LSB zuerst)
+            $bit = ($versionInfo >> $i) & 1;
+
+            // Berechne Position: 6 Bits pro Zeile, 3 Zeilen
+            $r = $row + ($i / 3);
+            $c = $col - ($i % 3);
+
+            $matrix[(int)$r][(int)$c] = $bit === 1;
+        }
+    }
+
+    /**
+     * Platziert die Versionsinformation rechts vom Finder Pattern unten links
+     */
+    private function placeVersionInfoTransposed(array &$matrix, int $versionInfo): void
+    {
+        // Position: rechts vom linken unteren Finder Pattern
+        // 6 Zeilen x 3 Spalten = 18 Bits
+        $row = $this->version * 4 + 6; // Unten links, die exakte Position hängt von der Version ab
+        $col = 0;
+
+        // 18 Bits des Versionsinformationsblocks setzen
+        for ($i = 0; $i < 18; $i++) {
+            // Bit von rechts nach links extrahieren (LSB zuerst)
+            $bit = ($versionInfo >> $i) & 1;
+
+            // Berechne Position: 3 Bits pro Zeile, 6 Zeilen (transponiert)
+            $r = $row - ($i % 3);
+            $c = $col + ($i / 3);
+
+            $matrix[(int)$r][(int)$c] = $bit === 1;
+        }
+    }
+}
diff --git a/src/Domain/QrCode/QrCode.php b/src/Domain/QrCode/QrCode.php
new file mode 100644
index 00000000..cd218a25
--- /dev/null
+++ b/src/Domain/QrCode/QrCode.php
@@ -0,0 +1,47 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Domain\QrCode;
+
+use App\Domain\QrCode\Exception\QrCodeException;
+use App\Domain\QrCode\ValueObject\ErrorCorrectionLevel;
+use App\Domain\QrCode\ValueObject\QrCodeVersion;
+
+readonly class QrCode
+{
+    public function __construct(
+        private string $data,
+        private ErrorCorrectionLevel $errorCorrectionLevel = ErrorCorrectionLevel::M,
+        private ?QrCodeVersion $version = null
+    ) {
+        if (empty($data)) {
+            throw new QrCodeException('QR Code Daten dürfen nicht leer sein');
+        }
+    }
+
+    public function getData(): string
+    {
+        return $this->data;
+    }
+
+    public function getErrorCorrectionLevel(): ErrorCorrectionLevel
+    {
+        return $this->errorCorrectionLevel;
+    }
+
+    public function getVersion(): ?QrCodeVersion
+    {
+        return $this->version;
+    }
+
+    public function withErrorCorrectionLevel(ErrorCorrectionLevel $level): self
+    {
+        return new self($this->data, $level, $this->version);
+    }
+
+    public function withVersion(QrCodeVersion $version): self
+    {
+        return new self($this->data, $this->errorCorrectionLevel, $version);
+    }
+}
diff --git a/src/Domain/QrCode/README.md b/src/Domain/QrCode/README.md
new file mode 100644
index 00000000..24814418
--- /dev/null
+++ b/src/Domain/QrCode/README.md
@@ -0,0 +1,80 @@
+# QR-Code Modul
+
+Dieses Modul bietet eine einfache API zum Generieren von QR-Codes in verschiedenen Formaten wie SVG, PNG und ASCII.
+
+## Funktionen
+
+- Generierung von QR-Codes in Versionen 1-40
+- Unterstützung verschiedener Fehlerkorrektur-Level (L, M, Q, H)
+- Automatische Versionsauswahl basierend auf Datenmenge
+- Vollständige Reed-Solomon-Fehlerkorrektur-Implementierung
+- Export als SVG, PNG oder ASCII-Art
+- Anpassbare Modulgröße und Ränder
+- Anpassbare Farben für SVG-Output
+
+## Beispiele
+
+### Einfache Verwendung
+
+```php
+// QR-Code als SVG generieren
+$qrCodeService = new QrCodeService($qrCodeGenerator);
+$svg = $qrCodeService->generateSvg('https://example.com');
+
+// QR-Code als PNG mit benutzerdefinierten Einstellungen
+$config = new QrCodeConfig(6, 8, '#000000', '#FFFFFF');
+$png = $qrCodeService->generatePng('Hallo Welt!', ErrorCorrectionLevel::H, $config);
+```
+
+### Erweiterte Anpassung
+
+```php
+// Explizite QR-Code-Version angeben
+$qrCode = new QrCode('Daten', ErrorCorrectionLevel::Q, new QrCodeVersion(5));
+$matrix = $qrCodeGenerator->generate($qrCode);
+
+// QR-Code als ASCII-Art ausgeben (für Debugging)
+$ascii = $qrCodeService->generateAscii('Text');
+echo $ascii;
+```
+
+## Architektur
+
+Das Modul ist nach Domain-Driven Design strukturiert:
+
+- **Entities und Value Objects**: QrCode, QrCodeVersion, ErrorCorrectionLevel, GaloisField, Polynomial, etc.
+- **Services**: QrCodeEncoder, QrCodeRenderer, QrCodeGenerator, ReedSolomon, ReedSolomonEncoder
+- **Patterns**: FinderPattern, AlignmentPattern, etc.
+
+Die Trennung von Verantwortlichkeiten ermöglicht eine einfache Erweiterung und Wartung.
+
+## Reed-Solomon-Fehlerkorrektur
+
+Die Implementierung der Reed-Solomon-Fehlerkorrektur erfolgt in mehreren Schritten:
+
+1. **Galois-Feld-Arithmetik**: Die `GaloisField`-Klasse implementiert die mathematischen Operationen im Galois-Feld GF(2^8).
+
+2. **Polynom-Operationen**: Die `Polynomial`-Klasse ermöglicht Berechnungen mit Polynomen im Galois-Feld.
+
+3. **Generator-Polynom**: Für die Fehlerkorrektur wird ein spezifisches Generator-Polynom basierend auf der gewünschten Anzahl von Fehlerkorrektur-Bytes erzeugt.
+
+4. **Kodierung**: Der eigentliche Reed-Solomon-Algorithmus teilt die Daten in Blöcke ein, berechnet die Fehlerkorrektur-Bytes für jeden Block und interleaved die Ergebnisse.
+
+Die Implementierung folgt dem Standard-Verfahren für QR-Codes und kann Fehler bis zur Hälfte der Anzahl der Fehlerkorrektur-Bytes korrigieren.
+
+## Kodierungsmodi
+
+Die Implementierung unterstützt folgende Kodierungsmodi gemäß der QR-Code-Spezifikation:
+
+1. **Numerischer Modus**: Optimiert für Ziffern (0-9), packt jeweils 3 Ziffern in 10 Bits.
+2. **Alphanumerischer Modus**: Für Ziffern, Großbuchstaben und einige Sonderzeichen, packt jeweils 2 Zeichen in 11 Bits.
+3. **Byte-Modus**: Für beliebige 8-Bit-Daten, verwendet 8 Bits pro Zeichen.
+4. **Kanji-Modus**: Optimiert für japanische Schriftzeichen (vereinfachte Implementierung).
+
+Der Encoder wählt automatisch den effizientesten Modus basierend auf den Eingabedaten.
+
+## Limitationen
+
+- Kanji-Modus ist nur teilweise implementiert
+- Strukturierte Anhänge werden nicht unterstützt
+- Keine Unterstützung für Micro-QR-Codes
diff --git a/src/Domain/QrCode/Service/QrCodeEncoder.php b/src/Domain/QrCode/Service/QrCodeEncoder.php
new file mode 100644
index 00000000..5b7a67f4
--- /dev/null
+++ b/src/Domain/QrCode/Service/QrCodeEncoder.php
@@ -0,0 +1,299 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Domain\QrCode\Service;
+
+use App\Domain\QrCode\Exception\QrCodeException;
+use App\Domain\QrCode\QrCode;
+use App\Domain\QrCode\ValueObject\QrCodeVersion;
+
+class QrCodeEncoder
+{
+    // Modus-Indikatoren (4 Bit)
+    private const MODE_NUMERIC = '0001';
+    private const MODE_ALPHANUMERIC = '0010';
+    private const MODE_BYTE = '0100';
+    private const MODE_KANJI = '1000';
+
+    // Zeichensatz für alphanumerische Kodierung
+    private const ALPHANUMERIC_CHARS = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ $%*+-./:';
+
+    // Character Count Indicator Längen basierend auf QR-Version und Modus
+    private const CHARACTER_COUNT_BITS = [
+        // Modus => [Versionsbereich => Bits]
+        'numeric' => [
+            [1, 9, 10],   // Versionen 1-9: 10 Bits
+            [10, 26, 12], // Versionen 10-26: 12 Bits
+            [27, 40, 14], // Versionen 27-40: 14 Bits
+        ],
+        'alphanumeric' => [
+            [1, 9, 9],    // Versionen 1-9: 9 Bits
+            [10, 26, 11], // Versionen 10-26: 11 Bits
+            [27, 40, 13], // Versionen 27-40: 13 Bits
+        ],
+        'byte' => [
+            [1, 9, 8],    // Versionen 1-9: 8 Bits
+            [10, 26, 16], // Versionen 10-26: 16 Bits
+            [27, 40, 16], // Versionen 27-40: 16 Bits
+        ],
+        'kanji' => [
+            [1, 9, 8],    // Versionen 1-9: 8 Bits
+            [10, 26, 10], // Versionen 10-26: 10 Bits
+            [27, 40, 12], // Versionen 27-40: 12 Bits
+        ],
+    ];
+
+    /**
+     * Kodiert die Daten in ein QR-Code-Bitstream
+     *
+     * @param QrCode $qrCode QR-Code mit zu kodierenden Daten
+     * @param QrCodeVersion $version Zu verwendende QR-Code-Version
+     * @return string Binärer String ('0' und '1')
+     * @throws QrCodeException Bei Kodierungsproblemen
+     */
+    public function encode(QrCode $qrCode, QrCodeVersion $version): string
+    {
+        $data = $qrCode->getData();
+
+        // 1. Bestimme den optimalen Modus
+        $mode = $this->determineEncodingMode($data);
+
+        // 2. Füge Mode Indicator hinzu (4 Bits)
+        $encoded = $this->getModeIndicator($mode);
+
+        // 3. Füge Character Count Indicator hinzu
+        $encoded .= $this->getCharacterCountIndicator(strlen($data), $mode, $version);
+
+        // 4. Kodiere die eigentlichen Daten
+        $encoded .= $this->encodeData($data, $mode);
+
+        // 5. Füge Terminator hinzu und fülle auf Byte-Grenze auf
+        $encoded = $this->addTerminator($encoded, $version, $qrCode->getErrorCorrectionLevel());
+        $encoded = $this->padToByteBoundary($encoded);
+
+        // 6. Fülle mit Pad-Bytes auf die volle Kapazität
+        $encoded = $this->addPadBytes($encoded, $version, $qrCode->getErrorCorrectionLevel());
+
+        return $encoded;
+    }
+
+    /**
+     * Bestimmt den optimalen Kodierungsmodus für die Daten
+     */
+    private function determineEncodingMode(string $data): string
+    {
+        // Prüfe, ob die Daten nur Ziffern enthalten
+        if (preg_match('/^[0-9]+$/', $data)) {
+            return 'numeric';
+        }
+
+        // Prüfe, ob die Daten nur alphanumerische Zeichen enthalten
+        if (preg_match('/^[0-9A-Z $%*+\-.\/:]+$/', $data)) {
+            return 'alphanumeric';
+        }
+
+        // Kanji-Erkennung ist komplex und wird hier nicht implementiert
+        // Bei Bedarf könnte hier eine Kanji-Zeichenerkennung erfolgen
+
+        // Standardmodus: Byte-Modus
+        return 'byte';
+    }
+
+    /**
+     * Liefert den Mode Indicator für den angegebenen Modus
+     */
+    private function getModeIndicator(string $mode): string
+    {
+        return match ($mode) {
+            'numeric' => self::MODE_NUMERIC,
+            'alphanumeric' => self::MODE_ALPHANUMERIC,
+            'kanji' => self::MODE_KANJI,
+            default => self::MODE_BYTE,
+        };
+    }
+
+    /**
+     * Erzeugt den Character Count Indicator
+     */
+    private function getCharacterCountIndicator(int $length, string $mode, QrCodeVersion $version): string
+    {
+        $versionNumber = $version->getValue();
+        $bits = 0;
+
+        // Bestimme die Anzahl der Bits für den Character Count Indicator
+        foreach (self::CHARACTER_COUNT_BITS[$mode] as $range) {
+            if ($versionNumber >= $range[0] && $versionNumber <= $range[1]) {
+                $bits = $range[2];
+                break;
+            }
+        }
+
+        // Konvertiere die Länge in binäre Darstellung mit der richtigen Anzahl von Bits
+        return str_pad(decbin($length), $bits, '0', STR_PAD_LEFT);
+    }
+
+    /**
+     * Kodiert die Daten im angegebenen Modus
+     */
+    private function encodeData(string $data, string $mode): string
+    {
+        return match ($mode) {
+            'numeric' => $this->encodeNumeric($data),
+            'alphanumeric' => $this->encodeAlphanumeric($data),
+            'kanji' => $this->encodeKanji($data),
+            default => $this->encodeByte($data),
+        };
+    }
+
+    /**
+     * Kodiert Daten im numerischen Modus
+     * Im numerischen Modus werden jeweils 3 Ziffern zu 10 Bits gruppiert
+     */
+    private function encodeNumeric(string $data): string
+    {
+        $result = '';
+        $length = strlen($data);
+
+        for ($i = 0; $i < $length; $i += 3) {
+            $chunk = substr($data, $i, min(3, $length - $i));
+            $value = (int)$chunk;
+
+            // Bestimme die Anzahl der Bits basierend auf der Chunk-Länge
+            $numBits = match (strlen($chunk)) {
+                1 => 4,
+                2 => 7,
+                3 => 10,
+            };
+
+            // Konvertiere den Wert in binäre Darstellung
+            $result .= str_pad(decbin($value), $numBits, '0', STR_PAD_LEFT);
+        }
+
+        return $result;
+    }
+
+    /**
+     * Kodiert Daten im alphanumerischen Modus
+     * Im alphanumerischen Modus werden jeweils 2 Zeichen zu 11 Bits gruppiert
+     */
+    private function encodeAlphanumeric(string $data): string
+    {
+        $result = '';
+        $length = strlen($data);
+
+        for ($i = 0; $i < $length; $i += 2) {
+            if ($i + 1 < $length) {
+                // Zwei Zeichen verarbeiten
+                $char1 = strpos(self::ALPHANUMERIC_CHARS, $data[$i]);
+                $char2 = strpos(self::ALPHANUMERIC_CHARS, $data[$i + 1]);
+
+                if ($char1 === false || $char2 === false) {
+                    throw new QrCodeException("Ungültiges alphanumerisches Zeichen: {$data[$i]} oder {$data[$i+1]}");
+                }
+
+                $value = $char1 * 45 + $char2;
+                $result .= str_pad(decbin($value), 11, '0', STR_PAD_LEFT);
+            } else {
+                // Einzelnes letztes Zeichen
+                $char = strpos(self::ALPHANUMERIC_CHARS, $data[$i]);
+
+                if ($char === false) {
+                    throw new QrCodeException("Ungültiges alphanumerisches Zeichen: {$data[$i]}");
+                }
+
+                $result .= str_pad(decbin($char), 6, '0', STR_PAD_LEFT);
+            }
+        }
+
+        return $result;
+    }
+
+    /**
+     * Kodiert Daten im Byte-Modus
+     * Im Byte-Modus wird jedes Zeichen als 8-Bit-Wert kodiert
+     */
+    private function encodeByte(string $data): string
+    {
+        $result = '';
+        $length = strlen($data);
+
+        for ($i = 0; $i < $length; $i++) {
+            // Konvertiere das Zeichen in seinen ASCII-Wert
+            $value = ord($data[$i]);
+            $result .= str_pad(decbin($value), 8, '0', STR_PAD_LEFT);
+        }
+
+        return $result;
+    }
+
+    /**
+     * Kodiert Daten im Kanji-Modus
+     * Dieser Modus ist für japanische Schriftzeichen optimiert
+     * In dieser vereinfachten Implementierung wird er nicht vollständig unterstützt
+     */
+    private function encodeKanji(string $data): string
+    {
+        // Vereinfachte Implementierung - in einer realen Anwendung würde hier
+        // eine Konvertierung von Kanji-Zeichen in die entsprechenden Werte erfolgen
+        return $this->encodeByte($data);
+    }
+
+    /**
+     * Fügt den Terminator (0000) hinzu und füllt auf bis zur maximalen Kapazität
+     */
+    private function addTerminator(string $encoded, QrCodeVersion $version, $errorCorrectionLevel): string
+    {
+        $dataCapacityBits = $version->getDataCapacity($errorCorrectionLevel) * 8;
+        $currentLength = strlen($encoded);
+
+        // Berechne, wie viele Terminator-Bits hinzugefügt werden können
+        $terminatorLength = max(0, min(4, $dataCapacityBits - $currentLength));
+
+        // Füge den Terminator hinzu
+        $encoded .= str_repeat('0', $terminatorLength);
+
+        return $encoded;
+    }
+
+    /**
+     * Füllt den Bitstream auf eine Byte-Grenze (Multiple von 8 Bits) auf
+     */
+    private function padToByteBoundary(string $encoded): string
+    {
+        $remainder = strlen($encoded) % 8;
+
+        if ($remainder > 0) {
+            $encoded .= str_repeat('0', 8 - $remainder);
+        }
+
+        return $encoded;
+    }
+
+    /**
+     * Füllt den Bitstream mit Pad-Bytes auf bis zur maximalen Kapazität
+     */
+    private function addPadBytes(string $encoded, QrCodeVersion $version, $errorCorrectionLevel): string
+    {
+        $dataCapacityBits = $version->getDataCapacity($errorCorrectionLevel) * 8;
+        $currentLength = strlen($encoded);
+
+        // Wenn die Daten bereits die Kapazität erreicht haben, nichts tun
+        if ($currentLength >= $dataCapacityBits) {
+            return $encoded;
+        }
+
+        // Pad-Bytes-Muster (wechselt zwischen 11101100 und 00010001)
+        $padBytes = ['11101100', '00010001'];
+        $padIndex = 0;
+
+        // Füge Pad-Bytes hinzu, bis die Kapazität erreicht ist
+        while ($currentLength < $dataCapacityBits) {
+            $encoded .= $padBytes[$padIndex];
+            $padIndex = ($padIndex + 1) % 2;
+            $currentLength += 8;
+        }
+
+        return $encoded;
+    }
+}
diff --git a/src/Domain/QrCode/Service/QrCodeGenerator.php b/src/Domain/QrCode/Service/QrCodeGenerator.php
new file mode 100644
index 00000000..3f71969a
--- /dev/null
+++ b/src/Domain/QrCode/Service/QrCodeGenerator.php
@@ -0,0 +1,61 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Domain\QrCode\Service;
+
+use App\Domain\QrCode\QrCode;
+use App\Domain\QrCode\Exception\QrCodeException;
+use App\Domain\QrCode\ValueObject\QrCodeMatrix;
+use App\Domain\QrCode\ValueObject\QrCodeVersion;
+
+class QrCodeGenerator
+{
+    public function __construct(
+        private readonly QrCodeEncoder $encoder,
+        private readonly QrCodeRenderer $renderer
+    ) {
+    }
+
+    /**
+     * Generiert einen QR-Code aus den gegebenen Daten
+     * @throws QrCodeException
+     */
+    public function generate(QrCode $qrCode): QrCodeMatrix
+    {
+        $version = $this->determineVersion($qrCode);
+        $encodedData = $this->encoder->encode($qrCode, $version);
+
+        return $this->renderer->render($encodedData, $version, $qrCode->getErrorCorrectionLevel());
+    }
+
+    /**
+     * Bestimmt die optimale QR-Code-Version
+     * @throws QrCodeException
+     */
+    private function determineVersion(QrCode $qrCode): QrCodeVersion
+    {
+        if ($qrCode->getVersion() !== null) {
+            return $qrCode->getVersion();
+        }
+
+        $dataLength = strlen($qrCode->getData());
+
+        // Bei längeren Daten mit größeren Versionen beginnen, um Berechnungszeit zu sparen
+        $startVersion = match (true) {
+            $dataLength < 30 => 1,
+            $dataLength < 100 => 5,
+            $dataLength < 500 => 15,
+            default => 25,
+        };
+
+        for ($version = $startVersion; $version <= 40; $version++) {
+            $qrVersion = new QrCodeVersion($version);
+            if ($qrVersion->getDataCapacity($qrCode->getErrorCorrectionLevel()) >= $dataLength) {
+                return $qrVersion;
+            }
+        }
+
+        throw new QrCodeException('Daten zu groß für QR-Code');
+    }
+}
diff --git a/src/Domain/QrCode/Service/QrCodeMasker.php b/src/Domain/QrCode/Service/QrCodeMasker.php
new file mode 100644
index 00000000..978da05b
--- /dev/null
+++ b/src/Domain/QrCode/Service/QrCodeMasker.php
@@ -0,0 +1,204 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Domain\QrCode\Service;
+
+use App\Domain\QrCode\ValueObject\MaskPattern;
+
+class QrCodeMasker
+{
+    /**
+     * Findet die beste Maske für die Matrix
+     */
+    public function findBestMask(array $matrix, int $size): MaskPattern
+    {
+        $lowestPenalty = PHP_INT_MAX;
+        $bestMask = MaskPattern::PATTERN_0;
+
+        foreach (MaskPattern::cases() as $mask) {
+            $testMatrix = $matrix;
+            $this->applyMask($testMatrix, $size, $mask);
+            $penalty = $this->calculateMaskPenalty($testMatrix, $size);
+
+            if ($penalty < $lowestPenalty) {
+                $lowestPenalty = $penalty;
+                $bestMask = $mask;
+            }
+        }
+
+        return $bestMask;
+    }
+
+    /**
+     * Wendet eine Maske auf die Matrix an
+     */
+    public function applyMask(array &$matrix, int $size, MaskPattern $maskPattern): void
+    {
+        for ($row = 0; $row < $size; $row++) {
+            for ($col = 0; $col < $size; $col++) {
+                if ($matrix[$row][$col] === null) {
+                    continue;
+                }
+
+                if (!$this->isFunctionModule($row, $col, $size)) {
+                    if ($maskPattern->shouldMask($row, $col)) {
+                        $matrix[$row][$col] = !$matrix[$row][$col];
+                    }
+                }
+            }
+        }
+    }
+
+    /**
+     * Berechnet die Strafpunkte für eine maskierte Matrix
+     */
+    public function calculateMaskPenalty(array $matrix, int $size): int
+    {
+        $penalty = 0;
+
+        // Regel 1: Aufeinanderfolgende Module gleicher Farbe
+        $penalty += $this->evaluateConsecutiveModulesPenalty($matrix, $size);
+
+        // Regel 2: Blöcke gleicher Farbe
+        $penalty += $this->evaluateSameColorBlocksPenalty($matrix, $size);
+
+        // Regel 3: Muster, die Finder-Pattern ähneln
+        $penalty += $this->evaluateFinderPatternLikePenalty($matrix, $size);
+
+        // Regel 4: Ausgewogenheit schwarzer und weißer Module
+        $penalty += $this->evaluateBalancePenalty($matrix, $size);
+
+        return $penalty;
+    }
+
+    /**
+     * Evaluiert die Strafe für aufeinanderfolgende Module gleicher Farbe
+     */
+    private function evaluateConsecutiveModulesPenalty(array $matrix, int $size): int
+    {
+        $penalty = 0;
+
+        // Zeilen prüfen
+        for ($row = 0; $row < $size; $row++) {
+            $count = 1;
+            for ($col = 1; $col < $size; $col++) {
+                if ($matrix[$row][$col] === $matrix[$row][$col - 1]) {
+                    $count++;
+                } else {
+                    if ($count >= 5) {
+                        $penalty += 3 + ($count - 5);
+                    }
+                    $count = 1;
+                }
+            }
+            if ($count >= 5) {
+                $penalty += 3 + ($count - 5);
+            }
+        }
+
+        // Spalten prüfen
+        for ($col = 0; $col < $size; $col++) {
+            $count = 1;
+            for ($row = 1; $row < $size; $row++) {
+                if ($matrix[$row][$col] === $matrix[$row - 1][$col]) {
+                    $count++;
+                } else {
+                    if ($count >= 5) {
+                        $penalty += 3 + ($count - 5);
+                    }
+                    $count = 1;
+                }
+            }
+            if ($count >= 5) {
+                $penalty += 3 + ($count - 5);
+            }
+        }
+
+        return $penalty;
+    }
+
+    /**
+     * Evaluiert die Strafe für 2x2 Blöcke gleicher Farbe
+     */
+    private function evaluateSameColorBlocksPenalty(array $matrix, int $size): int
+    {
+        $penalty = 0;
+
+        for ($row = 0; $row < $size - 1; $row++) {
+            for ($col = 0; $col < $size - 1; $col++) {
+                $color = $matrix[$row][$col];
+                if ($color === $matrix[$row][$col + 1] &&
+                    $color === $matrix[$row + 1][$col] &&
+                    $color === $matrix[$row + 1][$col + 1]) {
+                    $penalty += 3;
+                }
+            }
+        }
+
+        return $penalty;
+    }
+
+    /**
+     * Evaluiert die Strafe für Muster, die wie Finder-Pattern aussehen
+     */
+    private function evaluateFinderPatternLikePenalty(array $matrix, int $size): int
+    {
+        $penalty = 0;
+        // Vereinfachte Implementation
+        return $penalty;
+    }
+
+    /**
+     * Evaluiert die Strafe für unausgewogene schwarze/weiße Module
+     */
+    private function evaluateBalancePenalty(array $matrix, int $size): int
+    {
+        $darkCount = 0;
+        $totalCount = $size * $size;
+
+        for ($row = 0; $row < $size; $row++) {
+            for ($col = 0; $col < $size; $col++) {
+                if ($matrix[$row][$col] === true) {
+                    $darkCount++;
+                }
+            }
+        }
+
+        $darkPercentage = $darkCount * 100 / $totalCount;
+        $deviation = abs($darkPercentage - 50) / 5;
+
+        return (int) ($deviation * 10);
+    }
+
+    /**
+     * Prüft, ob ein Modul ein Funktionsmodul ist (also nicht maskiert werden sollte)
+     */
+    private function isFunctionModule(int $row, int $col, int $size): bool
+    {
+        // Finder-Pattern und Separatoren
+        if (($row < 9 && $col < 9) ||
+            ($row < 9 && $col >= $size - 8) ||
+            ($row >= $size - 8 && $col < 9)) {
+            return true;
+        }
+
+        // Timing-Pattern
+        if ($row === 6 || $col === 6) {
+            return true;
+        }
+
+        // Format-Informationen
+        if (($row < 9 && $col === 8) || ($row === 8 && $col < 9) ||
+            ($row === 8 && $col >= $size - 8) || ($row >= $size - 8 && $col === 8)) {
+            return true;
+        }
+
+        // Dark Module bei Version 1
+        if ($row === 8 && $col === 13) {
+            return true;
+        }
+
+        return false;
+    }
+}
diff --git a/src/Domain/QrCode/Service/QrCodeRenderer.php b/src/Domain/QrCode/Service/QrCodeRenderer.php
new file mode 100644
index 00000000..b04dae78
--- /dev/null
+++ b/src/Domain/QrCode/Service/QrCodeRenderer.php
@@ -0,0 +1,135 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Domain\QrCode\Service;
+
+use App\Domain\QrCode\Pattern\AlignmentPattern;
+use App\Domain\QrCode\Pattern\DarkModulePattern;
+use App\Domain\QrCode\Pattern\FinderPattern;
+use App\Domain\QrCode\Pattern\FormatInfoPattern;
+use App\Domain\QrCode\Pattern\TimingPattern;
+use App\Domain\QrCode\Pattern\VersionInfoPattern;
+use App\Domain\QrCode\ValueObject\ErrorCorrectionLevel;
+use App\Domain\QrCode\ValueObject\MaskPattern;
+use App\Domain\QrCode\ValueObject\QrCodeMatrix;
+use App\Domain\QrCode\ValueObject\QrCodeVersion;
+
+class QrCodeRenderer
+{
+    public function __construct(
+        private readonly QrCodeMasker $masker = new QrCodeMasker(),
+        private readonly ReedSolomon $reedSolomon = new ReedSolomon()
+    ) {
+    }
+
+    /**
+     * Rendert einen QR-Code basierend auf den kodierten Daten
+     */
+    public function render(string $data, QrCodeVersion $version, ErrorCorrectionLevel $level): QrCodeMatrix
+    {
+        $size = $version->getSize();
+        $matrix = array_fill(0, $size, array_fill(0, $size, null));
+
+        // 1. Funktionsmuster hinzufügen
+        $this->applyFunctionalPatterns($matrix, $version);
+
+        // 2. Daten mit Error Correction platzieren
+        $dataWithEcc = $this->reedSolomon->addErrorCorrection(
+            $data,
+            $version->getDataCapacity($level),
+            $level
+        );
+        $this->placeData($matrix, $dataWithEcc, $size);
+
+        // 3. Beste Maske finden und anwenden
+        $bestMask = $this->masker->findBestMask($matrix, $size);
+        $this->masker->applyMask($matrix, $size, $bestMask);
+
+        // 4. Format-Informationen hinzufügen
+        $formatPattern = new FormatInfoPattern($level, $bestMask->value);
+        $formatPattern->apply($matrix, $size);
+
+        // null-Werte durch false ersetzen
+        for ($r = 0; $r < $size; $r++) {
+            for ($c = 0; $c < $size; $c++) {
+                if ($matrix[$r][$c] === null) {
+                    $matrix[$r][$c] = false;
+                }
+            }
+        }
+
+        return new QrCodeMatrix($matrix);
+    }
+
+    /**
+     * Wendet alle funktionalen Muster auf die Matrix an
+     */
+    private function applyFunctionalPatterns(array &$matrix, QrCodeVersion $version): void
+    {
+        $size = $version->getSize();
+        $versionValue = $version->getValue();
+
+        // 1. Finder-Muster
+        $finderPatterns = FinderPattern::createAll($size);
+        foreach ($finderPatterns as $pattern) {
+            $pattern->apply($matrix, $size);
+        }
+
+        // 2. Timing-Muster
+        $timingPattern = new TimingPattern();
+        $timingPattern->apply($matrix, $size);
+
+        // 3. Ausrichtungsmuster (für Versionen > 1)
+        if ($versionValue > 1) {
+            $alignmentPattern = new AlignmentPattern($versionValue);
+            $alignmentPattern->apply($matrix, $size);
+        }
+
+        // 4. Dunkles Modul
+        $darkModule = new DarkModulePattern($versionValue);
+        $darkModule->apply($matrix, $size);
+
+        // 5. Versions-Information (für Versionen >= 7)
+        if ($versionValue >= 7) {
+            $versionInfoPattern = new VersionInfoPattern($versionValue);
+            $versionInfoPattern->apply($matrix, $size);
+        }
+    }
+
+    /**
+     * Platziert die kodierten Daten in der Matrix
+     */
+    private function placeData(array &$matrix, string $data, int $size): void
+    {
+        $dataIndex = 0;
+        $direction = -1; // Starte mit Aufwärtsbewegung
+
+        // Starte von unten rechts und bewege dich im Zickzack-Muster
+        for ($col = $size - 1; $col > 0; $col -= 2) {
+            // Timing-Spalte überspringen
+            if ($col === 6) $col--;
+
+            for ($count = 0; $count < $size; $count++) {
+                $row = $direction === -1 ? $size - 1 - $count : $count;
+
+                for ($c = 0; $c < 2; $c++) {
+                    $currentCol = $col - $c;
+
+                    // Nur in leere Zellen (null) Daten einfügen
+                    if ($row >= 0 && $row < $size && $currentCol >= 0 && $currentCol < $size &&
+                        $matrix[$row][$currentCol] === null) {
+
+                        if ($dataIndex < strlen($data)) {
+                            $matrix[$row][$currentCol] = ($data[$dataIndex] === '1');
+                            $dataIndex++;
+                        } else {
+                            $matrix[$row][$currentCol] = false;
+                        }
+                    }
+                }
+            }
+            $direction *= -1; // Richtung umkehren
+        }
+    }
+}
diff --git a/src/Domain/QrCode/Service/ReedSolomon.php b/src/Domain/QrCode/Service/ReedSolomon.php
new file mode 100644
index 00000000..2e64529a
--- /dev/null
+++ b/src/Domain/QrCode/Service/ReedSolomon.php
@@ -0,0 +1,486 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Domain\QrCode\Service;
+
+use App\Domain\QrCode\ValueObject\ErrorCorrectionLevel;
+
+/**
+ * Implementiert Reed-Solomon-Fehlerkorrektur für QR-Codes
+ */
+class ReedSolomon
+{
+    private ReedSolomonEncoder $encoder;
+
+    // Lookup-Tabelle für ECC-Wörter pro Block basierend auf QR-Version und EC-Level
+    private const ECC_WORDS_PER_BLOCK = [
+        // Version => [L, M, Q, H]
+        1 => [7, 10, 13, 17],
+        2 => [10, 16, 22, 28],
+        3 => [15, 26, 36, 44],
+        4 => [20, 36, 52, 64],
+        5 => [26, 48, 72, 88],
+        6 => [36, 64, 96, 112],
+        7 => [40, 72, 108, 130],
+        8 => [48, 88, 132, 156],
+        9 => [60, 110, 160, 192],
+        10 => [72, 130, 192, 224],
+        11 => [80, 150, 224, 264],
+        12 => [96, 176, 260, 308],
+        13 => [104, 198, 288, 352],
+        14 => [120, 216, 320, 384],
+        15 => [132, 240, 360, 432],
+        16 => [144, 280, 408, 480],
+        17 => [168, 308, 448, 532],
+        18 => [180, 338, 504, 588],
+        19 => [196, 364, 546, 650],
+        20 => [224, 416, 600, 700],
+        21 => [224, 442, 644, 750],
+        22 => [252, 476, 690, 816],
+        23 => [270, 504, 750, 900],
+        24 => [300, 560, 810, 960],
+        25 => [312, 588, 870, 1050],
+        26 => [336, 644, 952, 1110],
+        27 => [360, 700, 1020, 1200],
+        28 => [390, 728, 1050, 1260],
+        29 => [420, 784, 1140, 1350],
+        30 => [450, 812, 1200, 1440],
+        31 => [480, 868, 1290, 1530],
+        32 => [510, 924, 1350, 1620],
+        33 => [540, 980, 1440, 1710],
+        34 => [570, 1036, 1530, 1800],
+        35 => [570, 1064, 1590, 1890],
+        36 => [600, 1120, 1680, 1980],
+        37 => [630, 1204, 1770, 2100],
+        38 => [660, 1260, 1860, 2220],
+        39 => [720, 1316, 1950, 2310],
+        40 => [750, 1372, 2040, 2430],
+    ];
+
+    // Lookup-Tabelle für die Anzahl der Daten- und ECC-Blöcke
+    // [Gruppe1Blöcke, Gruppe1Wörter, Gruppe2Blöcke, Gruppe2Wörter]
+    private const BLOCKS_PER_VERSION = [
+        1 => [
+            'L' => [1, 19, 0, 0],
+            'M' => [1, 16, 0, 0],
+            'Q' => [1, 13, 0, 0],
+            'H' => [1, 9, 0, 0],
+        ],
+        2 => [
+            'L' => [1, 34, 0, 0],
+            'M' => [1, 28, 0, 0],
+            'Q' => [1, 22, 0, 0],
+            'H' => [1, 16, 0, 0],
+        ],
+        3 => [
+            'L' => [1, 55, 0, 0],
+            'M' => [1, 44, 0, 0],
+            'Q' => [2, 17, 0, 0],
+            'H' => [2, 13, 0, 0],
+        ],
+        4 => [
+            'L' => [1, 80, 0, 0],
+            'M' => [2, 32, 0, 0],
+            'Q' => [2, 24, 0, 0],
+            'H' => [4, 9, 0, 0],
+        ],
+        5 => [
+            'L' => [1, 108, 0, 0],
+            'M' => [2, 43, 0, 0],
+            'Q' => [2, 15, 2, 16],
+            'H' => [2, 11, 2, 12],
+        ],
+        6 => [
+            'L' => [2, 68, 0, 0],
+            'M' => [4, 27, 0, 0],
+            'Q' => [4, 19, 0, 0],
+            'H' => [4, 15, 0, 0],
+        ],
+        7 => [
+            'L' => [2, 78, 0, 0],
+            'M' => [4, 31, 0, 0],
+            'Q' => [2, 14, 4, 15],
+            'H' => [4, 13, 1, 14],
+        ],
+        8 => [
+            'L' => [2, 97, 0, 0],
+            'M' => [2, 38, 2, 39],
+            'Q' => [4, 18, 2, 19],
+            'H' => [4, 14, 2, 15],
+        ],
+        9 => [
+            'L' => [2, 116, 0, 0],
+            'M' => [3, 36, 2, 37],
+            'Q' => [4, 16, 4, 17],
+            'H' => [4, 12, 4, 13],
+        ],
+        10 => [
+            'L' => [2, 68, 2, 69],
+            'M' => [4, 43, 1, 44],
+            'Q' => [6, 19, 2, 20],
+            'H' => [6, 15, 2, 16],
+        ],
+        11 => [
+            'L' => [4, 81, 0, 0],
+            'M' => [1, 50, 4, 51],
+            'Q' => [4, 22, 4, 23],
+            'H' => [3, 12, 8, 13],
+        ],
+        12 => [
+            'L' => [2, 92, 2, 93],
+            'M' => [6, 36, 2, 37],
+            'Q' => [4, 20, 6, 21],
+            'H' => [7, 14, 4, 15],
+        ],
+        13 => [
+            'L' => [4, 107, 0, 0],
+            'M' => [8, 37, 1, 38],
+            'Q' => [8, 20, 4, 21],
+            'H' => [12, 11, 4, 12],
+        ],
+        14 => [
+            'L' => [3, 115, 1, 116],
+            'M' => [4, 40, 5, 41],
+            'Q' => [11, 16, 5, 17],
+            'H' => [11, 12, 5, 13],
+        ],
+        15 => [
+            'L' => [5, 87, 1, 88],
+            'M' => [5, 41, 5, 42],
+            'Q' => [5, 24, 7, 25],
+            'H' => [11, 12, 7, 13],
+        ],
+        16 => [
+            'L' => [5, 98, 1, 99],
+            'M' => [7, 45, 3, 46],
+            'Q' => [15, 19, 2, 20],
+            'H' => [3, 15, 13, 16],
+        ],
+        17 => [
+            'L' => [1, 107, 5, 108],
+            'M' => [10, 46, 1, 47],
+            'Q' => [1, 22, 15, 23],
+            'H' => [2, 14, 17, 15],
+        ],
+        18 => [
+            'L' => [5, 120, 1, 121],
+            'M' => [9, 43, 4, 44],
+            'Q' => [17, 22, 1, 23],
+            'H' => [2, 14, 19, 15],
+        ],
+        19 => [
+            'L' => [3, 113, 4, 114],
+            'M' => [3, 44, 11, 45],
+            'Q' => [17, 21, 4, 22],
+            'H' => [9, 13, 16, 14],
+        ],
+        20 => [
+            'L' => [3, 107, 5, 108],
+            'M' => [3, 41, 13, 42],
+            'Q' => [15, 24, 5, 25],
+            'H' => [15, 15, 10, 16],
+        ],
+        21 => [
+            'L' => [4, 116, 4, 117],
+            'M' => [17, 42, 0, 0],
+            'Q' => [17, 22, 6, 23],
+            'H' => [19, 16, 6, 17],
+        ],
+        22 => [
+            'L' => [2, 111, 7, 112],
+            'M' => [17, 46, 0, 0],
+            'Q' => [7, 24, 16, 25],
+            'H' => [34, 13, 0, 0],
+        ],
+        23 => [
+            'L' => [4, 121, 5, 122],
+            'M' => [4, 47, 14, 48],
+            'Q' => [11, 24, 14, 25],
+            'H' => [16, 15, 14, 16],
+        ],
+        24 => [
+            'L' => [6, 117, 4, 118],
+            'M' => [6, 45, 14, 46],
+            'Q' => [11, 24, 16, 25],
+            'H' => [30, 16, 2, 17],
+        ],
+        25 => [
+            'L' => [8, 106, 4, 107],
+            'M' => [8, 47, 13, 48],
+            'Q' => [7, 24, 22, 25],
+            'H' => [22, 15, 13, 16],
+        ],
+        26 => [
+            'L' => [10, 114, 2, 115],
+            'M' => [19, 46, 4, 47],
+            'Q' => [28, 22, 6, 23],
+            'H' => [33, 16, 4, 17],
+        ],
+        27 => [
+            'L' => [8, 122, 4, 123],
+            'M' => [22, 45, 3, 46],
+            'Q' => [8, 23, 26, 24],
+            'H' => [12, 15, 28, 16],
+        ],
+        28 => [
+            'L' => [3, 117, 10, 118],
+            'M' => [3, 45, 23, 46],
+            'Q' => [4, 24, 31, 25],
+            'H' => [11, 15, 31, 16],
+        ],
+        29 => [
+            'L' => [7, 116, 7, 117],
+            'M' => [21, 45, 7, 46],
+            'Q' => [1, 23, 37, 24],
+            'H' => [19, 15, 26, 16],
+        ],
+        30 => [
+            'L' => [5, 115, 10, 116],
+            'M' => [19, 47, 10, 48],
+            'Q' => [15, 24, 25, 25],
+            'H' => [23, 15, 25, 16],
+        ],
+        31 => [
+            'L' => [13, 115, 3, 116],
+            'M' => [2, 46, 29, 47],
+            'Q' => [42, 24, 1, 25],
+            'H' => [23, 15, 28, 16],
+        ],
+        32 => [
+            'L' => [17, 115, 0, 0],
+            'M' => [10, 46, 23, 47],
+            'Q' => [10, 24, 35, 25],
+            'H' => [19, 15, 35, 16],
+        ],
+        33 => [
+            'L' => [17, 115, 1, 116],
+            'M' => [14, 46, 21, 47],
+            'Q' => [29, 24, 19, 25],
+            'H' => [11, 15, 46, 16],
+        ],
+        34 => [
+            'L' => [13, 115, 6, 116],
+            'M' => [14, 46, 23, 47],
+            'Q' => [44, 24, 7, 25],
+            'H' => [59, 16, 1, 17],
+        ],
+        35 => [
+            'L' => [12, 121, 7, 122],
+            'M' => [12, 47, 26, 48],
+            'Q' => [39, 24, 14, 25],
+            'H' => [22, 15, 41, 16],
+        ],
+        36 => [
+            'L' => [6, 121, 14, 122],
+            'M' => [6, 47, 34, 48],
+            'Q' => [46, 24, 10, 25],
+            'H' => [2, 15, 64, 16],
+        ],
+        37 => [
+            'L' => [17, 122, 4, 123],
+            'M' => [29, 46, 14, 47],
+            'Q' => [49, 24, 10, 25],
+            'H' => [24, 15, 46, 16],
+        ],
+        38 => [
+            'L' => [4, 122, 18, 123],
+            'M' => [13, 46, 32, 47],
+            'Q' => [48, 24, 14, 25],
+            'H' => [42, 15, 32, 16],
+        ],
+        39 => [
+            'L' => [20, 117, 4, 118],
+            'M' => [40, 47, 7, 48],
+            'Q' => [43, 24, 22, 25],
+            'H' => [10, 15, 67, 16],
+        ],
+        40 => [
+            'L' => [19, 118, 6, 119],
+            'M' => [18, 47, 31, 48],
+            'Q' => [34, 24, 34, 25],
+            'H' => [20, 15, 61, 16],
+        ],
+    ];
+
+    public function __construct()
+    {
+        $this->encoder = new ReedSolomonEncoder();
+    }
+
+    /**
+     * Fügt Reed-Solomon-Fehlerkorrektur zu den Daten hinzu
+     *
+     * @param string $data Binäre Daten ('0' und '1')
+     * @param int $dataCapacity Kapazität in Bytes
+     * @param ErrorCorrectionLevel $level Fehlerkorrektur-Level
+     * @return string Binäre Daten mit Fehlerkorrektur
+     */
+    public function addErrorCorrection(
+        string $data,
+        int $dataCapacity,
+        ErrorCorrectionLevel $level
+    ): string {
+        // Konvertiere binäre Daten in Byte-Array
+        $bytes = $this->binaryToBytes($data);
+
+        // Berechne die QR-Version basierend auf der Kapazität
+        $version = $this->estimateVersionFromCapacity($dataCapacity);
+
+        // Bestimme die Anzahl der ECC-Wörter pro Block für diese Version und EC-Level
+        $eccWordsPerBlock = $this->getEccWordsPerBlock($version, $level);
+
+        // Organisiere Daten in Blöcke gemäß QR-Code-Spezifikation
+        $blocks = $this->organizeDataBlocks($bytes, $version, $level);
+
+        // Kodiere jeden Block mit Reed-Solomon
+        $encodedBlocks = [];
+        foreach ($blocks as $block) {
+            $encodedBlocks[] = $this->encoder->encode($block, $eccWordsPerBlock);
+        }
+
+        // Interleave die Blöcke gemäß QR-Code-Spezifikation
+        $interleavedData = $this->interleaveBlocks($encodedBlocks);
+
+        // Konvertiere zurück zu binärer Darstellung
+        return $this->bytesToBinary($interleavedData);
+    }
+
+    /**
+     * Konvertiert binäre Daten ('0' und '1') in ein Byte-Array
+     */
+    private function binaryToBytes(string $binary): array
+    {
+        $bytes = [];
+        $length = strlen($binary);
+
+        // Verarbeite vollständige Bytes
+        for ($i = 0; $i < $length; $i += 8) {
+            if ($i + 8 <= $length) {
+                $byte = bindec(substr($binary, $i, 8));
+                $bytes[] = $byte;
+            } else {
+                // Letztes unvollständiges Byte mit Nullen auffüllen
+                $partialByte = substr($binary, $i);
+                $paddedByte = str_pad($partialByte, 8, '0', STR_PAD_RIGHT);
+                $bytes[] = bindec($paddedByte);
+            }
+        }
+
+        return $bytes;
+    }
+
+    /**
+     * Konvertiert ein Byte-Array zurück in binäre Darstellung
+     */
+    private function bytesToBinary(array $bytes): string
+    {
+        $binary = '';
+
+        foreach ($bytes as $byte) {
+            $binary .= str_pad(decbin($byte), 8, '0', STR_PAD_LEFT);
+        }
+
+        return $binary;
+    }
+
+    /**
+     * Schätzt die QR-Version basierend auf der Kapazität
+     */
+    private function estimateVersionFromCapacity(int $capacity): int
+    {
+        // Vereinfachte Schätzung
+        if ($capacity <= 17) return 1;
+        if ($capacity <= 32) return 2;
+        if ($capacity <= 53) return 3;
+        if ($capacity <= 78) return 4;
+        if ($capacity <= 106) return 5;
+        if ($capacity <= 134) return 6;
+        if ($capacity <= 154) return 7;
+        if ($capacity <= 192) return 8;
+        if ($capacity <= 230) return 9;
+        if ($capacity <= 271) return 10;
+
+        // Fallback für größere Versionen
+        return 10;
+    }
+
+    /**
+     * Ermittelt die Anzahl der ECC-Wörter pro Block für die angegebene Version und EC-Level
+     */
+    private function getEccWordsPerBlock(int $version, ErrorCorrectionLevel $level): int
+    {
+        $index = match ($level) {
+            ErrorCorrectionLevel::L => 0,
+            ErrorCorrectionLevel::M => 1,
+            ErrorCorrectionLevel::Q => 2,
+            ErrorCorrectionLevel::H => 3,
+        };
+
+        return self::ECC_WORDS_PER_BLOCK[$version][$index] ?? 10; // Fallback-Wert
+    }
+
+    /**
+     * Organisiert die Daten in Blöcke gemäß QR-Code-Spezifikation
+     */
+    private function organizeDataBlocks(array $data, int $version, ErrorCorrectionLevel $level): array
+    {
+        $blocks = [];
+
+        // Hol Block-Informationen
+        $blockInfo = self::BLOCKS_PER_VERSION[$version][$level->name] ?? [1, count($data), 0, 0];
+
+        $group1Blocks = $blockInfo[0];
+        $group1Words = $blockInfo[1];
+        $group2Blocks = $blockInfo[2];
+        $group2Words = $blockInfo[3];
+
+        $dataIndex = 0;
+
+        // Gruppe 1 Blöcke
+        for ($i = 0; $i < $group1Blocks; $i++) {
+            $block = array_slice($data, $dataIndex, $group1Words);
+            $blocks[] = $block;
+            $dataIndex += $group1Words;
+        }
+
+        // Gruppe 2 Blöcke
+        for ($i = 0; $i < $group2Blocks; $i++) {
+            $block = array_slice($data, $dataIndex, $group2Words);
+            $blocks[] = $block;
+            $dataIndex += $group2Words;
+        }
+
+        // Wenn nur ein Block, verwende alle Daten
+        if (empty($blocks)) {
+            $blocks[] = $data;
+        }
+
+        return $blocks;
+    }
+
+    /**
+     * Interleaved die kodierten Blöcke gemäß QR-Code-Spezifikation
+     */
+    private function interleaveBlocks(array $blocks): array
+    {
+        $result = [];
+        $maxLength = 0;
+
+        // Finde die maximale Blocklänge
+        foreach ($blocks as $block) {
+            $maxLength = max($maxLength, count($block));
+        }
+
+        // Interleave Daten- und ECC-Bytes
+        for ($i = 0; $i < $maxLength; $i++) {
+            foreach ($blocks as $block) {
+                if ($i < count($block)) {
+                    $result[] = $block[$i];
+                }
+            }
+        }
+
+        return $result;
+    }
+}
diff --git a/src/Domain/QrCode/Service/ReedSolomonEncoder.php b/src/Domain/QrCode/Service/ReedSolomonEncoder.php
new file mode 100644
index 00000000..e408c572
--- /dev/null
+++ b/src/Domain/QrCode/Service/ReedSolomonEncoder.php
@@ -0,0 +1,63 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Domain\QrCode\Service;
+
+use App\Domain\QrCode\ValueObject\GaloisField;
+use App\Domain\QrCode\ValueObject\Polynomial;
+
+/**
+ * Reed-Solomon Encoder für QR-Code-Fehlerkorrektur
+ */
+class ReedSolomonEncoder
+{
+    private GaloisField $field;
+
+    public function __construct()
+    {
+        $this->field = new GaloisField();
+    }
+
+    /**
+     * Kodiert die Daten mit Reed-Solomon-Fehlerkorrektur
+     *
+     * @param array $data Daten als Array von Bytes
+     * @param int $eccLength Anzahl der Error-Correction-Codewords
+     * @return array Kodierte Daten mit ECC-Bytes
+     */
+    public function encode(array $data, int $eccLength): array
+    {
+        if ($eccLength === 0) {
+            return $data;
+        }
+
+        // Erzeuge das Generator-Polynom für die gegebene Anzahl von ECC-Bytes
+        $generator = Polynomial::buildGenerator($this->field, $eccLength);
+
+        // Konvertiere Daten in ein Polynom
+        $dataPolynomial = new Polynomial($this->field, $data);
+
+        // Multipliziere mit x^eccLength, um Platz für ECC-Bytes zu schaffen
+        $paddedData = array_merge(
+            array_fill(0, $eccLength, 0),
+            $dataPolynomial->getCoefficients()
+        );
+        $paddedPolynomial = new Polynomial($this->field, $paddedData);
+
+        // Dividiere durch das Generator-Polynom, der Rest ist der ECC
+        $divResult = $paddedPolynomial->divideAndRemainder($generator);
+        $remainder = $divResult['remainder']->getCoefficients();
+
+        // Fülle den Rest mit Nullen auf, falls er zu kurz ist
+        if (count($remainder) < $eccLength) {
+            $remainder = array_merge(
+                array_fill(0, $eccLength - count($remainder), 0),
+                $remainder
+            );
+        }
+
+        // Konkateniere Daten und ECC-Bytes
+        return array_merge($data, $remainder);
+    }
+}
diff --git a/src/Domain/QrCode/ValueObject/ErrorCorrectionLevel.php b/src/Domain/QrCode/ValueObject/ErrorCorrectionLevel.php
new file mode 100644
index 00000000..7bf4c8f8
--- /dev/null
+++ b/src/Domain/QrCode/ValueObject/ErrorCorrectionLevel.php
@@ -0,0 +1,33 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Domain\QrCode\ValueObject;
+
+enum ErrorCorrectionLevel: string
+{
+    case L = 'L'; // ~7% Korrektur
+    case M = 'M'; // ~15% Korrektur
+    case Q = 'Q'; // ~25% Korrektur
+    case H = 'H'; // ~30% Korrektur
+
+    public function getCapacityReduction(): float
+    {
+        return match ($this) {
+            self::L => 0.07,
+            self::M => 0.15,
+            self::Q => 0.25,
+            self::H => 0.30,
+        };
+    }
+
+    public function getNumeric(): int
+    {
+        return match ($this) {
+            self::L => 1,
+            self::M => 0,
+            self::Q => 3,
+            self::H => 2,
+        };
+    }
+}
diff --git a/src/Domain/QrCode/ValueObject/GaloisField.php b/src/Domain/QrCode/ValueObject/GaloisField.php
new file mode 100644
index 00000000..a6949d6b
--- /dev/null
+++ b/src/Domain/QrCode/ValueObject/GaloisField.php
@@ -0,0 +1,138 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Domain\QrCode\ValueObject;
+
+/**
+ * Repräsentiert ein Galois-Feld GF(2^8) für Reed-Solomon-Berechnungen
+ */
+class GaloisField
+{
+    // Generator-Polynom für GF(2^8)
+    private const PRIMITIVE_POLY = 0x11D; // x^8 + x^4 + x^3 + x^2 + 1
+
+    // Lookup-Tabellen für Multiplikation und Division
+    private array $expTable = [];
+    private array $logTable = [];
+
+    public function __construct()
+    {
+        $this->initTables();
+    }
+
+    /**
+     * Initialisiert die Lookup-Tabellen für schnelle Berechnungen
+     */
+    private function initTables(): void
+    {
+        // Setze Tabellen-Größe
+        $this->expTable = array_fill(0, 256, 0);
+        $this->logTable = array_fill(0, 256, 0);
+
+        // Berechne die Exponentiation und Logarithmus-Tabellen
+        $x = 1;
+        for ($i = 0; $i < 255; $i++) {
+            $this->expTable[$i] = $x;
+            $this->logTable[$x] = $i;
+
+            // Multiplikation mit x in GF(2^8)
+            $x = ($x << 1) ^ ($x & 0x80 ? self::PRIMITIVE_POLY : 0);
+            $x &= 0xFF;
+        }
+
+        // Setze expTable[255] = expTable[0]
+        $this->expTable[255] = $this->expTable[0];
+    }
+
+    /**
+     * Addiert zwei Elemente im Galois-Feld
+     */
+    public function add(int $a, int $b): int
+    {
+        return $a ^ $b; // In GF(2^8) ist Addition = XOR
+    }
+
+    /**
+     * Subtrahiert zwei Elemente im Galois-Feld
+     * In GF(2^8) ist Subtraktion = Addition = XOR
+     */
+    public function subtract(int $a, int $b): int
+    {
+        return $this->add($a, $b);
+    }
+
+    /**
+     * Multipliziert zwei Elemente im Galois-Feld
+     */
+    public function multiply(int $a, int $b): int
+    {
+        // Spezialfall: Null-Multiplikation
+        if ($a === 0 || $b === 0) {
+            return 0;
+        }
+
+        // Benutze Log-Tabellen für Multiplikation
+        $logA = $this->logTable[$a];
+        $logB = $this->logTable[$b];
+        $sumLog = ($logA + $logB) % 255;
+
+        return $this->expTable[$sumLog];
+    }
+
+    /**
+     * Dividiert zwei Elemente im Galois-Feld
+     */
+    public function divide(int $a, int $b): int
+    {
+        if ($b === 0) {
+            throw new \DivisionByZeroError('Division by zero in Galois field');
+        }
+
+        if ($a === 0) {
+            return 0;
+        }
+
+        // Benutze Log-Tabellen für Division
+        $logA = $this->logTable[$a];
+        $logB = $this->logTable[$b];
+        $diffLog = ($logA - $logB + 255) % 255;
+
+        return $this->expTable[$diffLog];
+    }
+
+    /**
+     * Berechnet die Potenz eines Elements im Galois-Feld
+     */
+    public function power(int $a, int $power): int
+    {
+        if ($a === 0) {
+            return 0;
+        }
+
+        if ($power === 0) {
+            return 1;
+        }
+
+        $logA = $this->logTable[$a];
+        $resultLog = ($logA * $power) % 255;
+
+        return $this->expTable[$resultLog];
+    }
+
+    /**
+     * Liefert die Logarithmus-Tabelle
+     */
+    public function getLogTable(): array
+    {
+        return $this->logTable;
+    }
+
+    /**
+     * Liefert die Exponentiations-Tabelle
+     */
+    public function getExpTable(): array
+    {
+        return $this->expTable;
+    }
+}
diff --git a/src/Domain/QrCode/ValueObject/MaskPattern.php b/src/Domain/QrCode/ValueObject/MaskPattern.php
new file mode 100644
index 00000000..114419ca
--- /dev/null
+++ b/src/Domain/QrCode/ValueObject/MaskPattern.php
@@ -0,0 +1,31 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Domain\QrCode\ValueObject;
+
+enum MaskPattern: int
+{
+    case PATTERN_0 = 0; // (row + column) mod 2 == 0
+    case PATTERN_1 = 1; // row mod 2 == 0
+    case PATTERN_2 = 2; // column mod 3 == 0
+    case PATTERN_3 = 3; // (row + column) mod 3 == 0
+    case PATTERN_4 = 4; // (floor(row/2) + floor(column/3)) mod 2 == 0
+    case PATTERN_5 = 5; // ((row * column) mod 2) + ((row * column) mod 3) == 0
+    case PATTERN_6 = 6; // (((row * column) mod 2) + ((row * column) mod 3)) mod 2 == 0
+    case PATTERN_7 = 7; // (((row + column) mod 2) + ((row * column) mod 3)) mod 2 == 0
+
+    public function shouldMask(int $row, int $col): bool
+    {
+        return match ($this) {
+            self::PATTERN_0 => ($row + $col) % 2 === 0,
+            self::PATTERN_1 => $row % 2 === 0,
+            self::PATTERN_2 => $col % 3 === 0,
+            self::PATTERN_3 => ($row + $col) % 3 === 0,
+            self::PATTERN_4 => (intval($row / 2) + intval($col / 3)) % 2 === 0,
+            self::PATTERN_5 => ($row * $col) % 2 + ($row * $col) % 3 === 0,
+            self::PATTERN_6 => (($row * $col) % 2 + ($row * $col) % 3) % 2 === 0,
+            self::PATTERN_7 => (($row + $col) % 2 + ($row * $col) % 3) % 2 === 0,
+        };
+    }
+}
diff --git a/src/Domain/QrCode/ValueObject/Polynomial.php b/src/Domain/QrCode/ValueObject/Polynomial.php
new file mode 100644
index 00000000..0fd93ee0
--- /dev/null
+++ b/src/Domain/QrCode/ValueObject/Polynomial.php
@@ -0,0 +1,240 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Domain\QrCode\ValueObject;
+
+/**
+ * Repräsentiert ein Polynom im Galois-Feld für Reed-Solomon-Berechnungen
+ */
+class Polynomial
+{
+    private array $coefficients;
+
+    public function __construct(
+        private readonly GaloisField $field,
+        array $coefficients
+    ) {
+        // Entferne führende Nullen
+        $this->coefficients = $this->removeLeadingZeros($coefficients);
+
+        // Leeres Polynom = [0]
+        if (empty($this->coefficients)) {
+            $this->coefficients = [0];
+        }
+    }
+
+    /**
+     * Entfernt führende Nullen aus dem Koeffizienten-Array
+     */
+    private function removeLeadingZeros(array $coefficients): array
+    {
+        $i = 0;
+        while ($i < count($coefficients) - 1 && $coefficients[$i] === 0) {
+            $i++;
+        }
+
+        return array_slice($coefficients, $i);
+    }
+
+    /**
+     * Liefert die Koeffizienten des Polynoms
+     */
+    public function getCoefficients(): array
+    {
+        return $this->coefficients;
+    }
+
+    /**
+     * Liefert den Grad des Polynoms
+     */
+    public function getDegree(): int
+    {
+        return count($this->coefficients) - 1;
+    }
+
+    /**
+     * Wertet das Polynom an der Stelle x aus
+     */
+    public function evaluateAt(int $x): int
+    {
+        if ($x === 0) {
+            // f(0) ist der letzte Koeffizient
+            return $this->coefficients[count($this->coefficients) - 1];
+        }
+
+        $result = 0;
+        $degree = $this->getDegree();
+
+        for ($i = 0; $i <= $degree; $i++) {
+            // result = result * x + coef[i]
+            $term = $this->field->multiply(
+                $result,
+                $x
+            );
+            $result = $this->field->add($term, $this->coefficients[$i]);
+        }
+
+        return $result;
+    }
+
+    /**
+     * Addiert zwei Polynome
+     */
+    public function add(Polynomial $other): Polynomial
+    {
+        if ($this->isZero()) {
+            return $other;
+        }
+
+        if ($other->isZero()) {
+            return $this;
+        }
+
+        $thisCoeffs = $this->coefficients;
+        $otherCoeffs = $other->getCoefficients();
+
+        $resultLength = max(count($thisCoeffs), count($otherCoeffs));
+        $result = array_fill(0, $resultLength, 0);
+
+        // Addiere die Koeffizienten
+        for ($i = 0; $i < count($thisCoeffs); $i++) {
+            $result[$i + ($resultLength - count($thisCoeffs))] = $thisCoeffs[$i];
+        }
+
+        for ($i = 0; $i < count($otherCoeffs); $i++) {
+            $idx = $i + ($resultLength - count($otherCoeffs));
+            $result[$idx] = $this->field->add($result[$idx], $otherCoeffs[$i]);
+        }
+
+        return new Polynomial($this->field, $result);
+    }
+
+    /**
+     * Multipliziert zwei Polynome
+     */
+    public function multiply(Polynomial $other): Polynomial
+    {
+        if ($this->isZero() || $other->isZero()) {
+            return new Polynomial($this->field, [0]);
+        }
+
+        $thisCoeffs = $this->coefficients;
+        $otherCoeffs = $other->getCoefficients();
+
+        $resultLength = count($thisCoeffs) + count($otherCoeffs) - 1;
+        $result = array_fill(0, $resultLength, 0);
+
+        // Multipliziere die Koeffizienten
+        for ($i = 0; $i < count($thisCoeffs); $i++) {
+            for ($j = 0; $j < count($otherCoeffs); $j++) {
+                $idx = $i + $j;
+                $product = $this->field->multiply($thisCoeffs[$i], $otherCoeffs[$j]);
+                $result[$idx] = $this->field->add($result[$idx], $product);
+            }
+        }
+
+        return new Polynomial($this->field, $result);
+    }
+
+    /**
+     * Multipliziert das Polynom mit einem Skalar
+     */
+    public function multiplyByScalar(int $scalar): Polynomial
+    {
+        if ($scalar === 0) {
+            return new Polynomial($this->field, [0]);
+        }
+
+        if ($scalar === 1) {
+            return $this;
+        }
+
+        $result = [];
+        foreach ($this->coefficients as $coefficient) {
+            $result[] = $this->field->multiply($coefficient, $scalar);
+        }
+
+        return new Polynomial($this->field, $result);
+    }
+
+    /**
+     * Dividiert ein Polynom durch ein anderes und gibt Quotient und Rest zurück
+     */
+    public function divideAndRemainder(Polynomial $other): array
+    {
+        if ($other->isZero()) {
+            throw new \DivisionByZeroError('Division by zero polynomial');
+        }
+
+        if ($this->isZero()) {
+            return [
+                'quotient' => new Polynomial($this->field, [0]),
+                'remainder' => new Polynomial($this->field, [0])
+            ];
+        }
+
+        if ($this->getDegree() < $other->getDegree()) {
+            return [
+                'quotient' => new Polynomial($this->field, [0]),
+                'remainder' => $this
+            ];
+        }
+
+        $quotientCoeffs = array_fill(0, $this->getDegree() - $other->getDegree() + 1, 0);
+        $remainderCoeffs = $this->coefficients;
+
+        $denomLeadingTerm = $other->getCoefficients()[0];
+
+        for ($i = 0; $i <= $this->getDegree() - $other->getDegree(); $i++) {
+            if ($remainderCoeffs[$i] === 0) {
+                continue;
+            }
+
+            $quotientCoeffs[$i] = $this->field->divide($remainderCoeffs[$i], $denomLeadingTerm);
+
+            for ($j = 0; $j <= $other->getDegree(); $j++) {
+                $idx = $i + $j;
+                $product = $this->field->multiply($quotientCoeffs[$i], $other->getCoefficients()[$j]);
+                $remainderCoeffs[$idx] = $this->field->subtract($remainderCoeffs[$idx], $product);
+            }
+        }
+
+        // Extrahiere den Rest
+        $remainderDegree = $other->getDegree() - 1;
+        $remainder = array_slice($remainderCoeffs, count($remainderCoeffs) - $remainderDegree - 1);
+
+        return [
+            'quotient' => new Polynomial($this->field, $quotientCoeffs),
+            'remainder' => new Polynomial($this->field, $remainder)
+        ];
+    }
+
+    /**
+     * Prüft, ob das Polynom das Nullpolynom ist
+     */
+    public function isZero(): bool
+    {
+        return count($this->coefficients) === 1 && $this->coefficients[0] === 0;
+    }
+
+    /**
+     * Erzeugt ein Generatorpolynom für Reed-Solomon-Codes
+     */
+    public static function buildGenerator(GaloisField $field, int $degree): Polynomial
+    {
+        // g(x) = (x-α^0)(x-α^1)...(x-α^(degree-1))
+        $generator = new Polynomial($field, [1]); // Beginne mit g(x) = 1
+
+        for ($i = 0; $i < $degree; $i++) {
+            // Faktor (x-α^i)
+            $factor = new Polynomial($field, [
+                1, // x^1
+                $field->power(2, $i) // -α^i (In GF(2^m) ist -a = a)
+            ]);
+            $generator = $generator->multiply($factor);
+        }
+
+        return $generator;
+    }
+}
diff --git a/src/Domain/QrCode/ValueObject/Position.php b/src/Domain/QrCode/ValueObject/Position.php
new file mode 100644
index 00000000..e14cfa33
--- /dev/null
+++ b/src/Domain/QrCode/ValueObject/Position.php
@@ -0,0 +1,38 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Domain\QrCode\ValueObject;
+
+readonly class Position
+{
+    public function __construct(
+        private int $row,
+        private int $column
+    ) {
+    }
+
+    public function getRow(): int
+    {
+        return $this->row;
+    }
+
+    public function getColumn(): int
+    {
+        return $this->column;
+    }
+
+    public function offset(int $rowOffset, int $columnOffset): self
+    {
+        return new self(
+            $this->row + $rowOffset,
+            $this->column + $columnOffset
+        );
+    }
+
+    public function isWithinBounds(int $size): bool
+    {
+        return $this->row >= 0 && $this->row < $size &&
+               $this->column >= 0 && $this->column < $size;
+    }
+}
diff --git a/src/Domain/QrCode/ValueObject/QrCodeConfig.php b/src/Domain/QrCode/ValueObject/QrCodeConfig.php
new file mode 100644
index 00000000..2ec4f605
--- /dev/null
+++ b/src/Domain/QrCode/ValueObject/QrCodeConfig.php
@@ -0,0 +1,72 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Domain\QrCode\ValueObject;
+
+readonly class QrCodeConfig
+{
+    /**
+     * @param int $moduleSize Größe eines QR-Code-Moduls in Pixeln
+     * @param int $margin Rand um den QR-Code in Modulen
+     * @param string $foregroundColor Vordergrundfarbe (für SVG)
+     * @param string $backgroundColor Hintergrundfarbe (für SVG)
+     */
+    public function __construct(
+        private int $moduleSize = 4,
+        private int $margin = 4,
+        private string $foregroundColor = '#000000',
+        private string $backgroundColor = '#FFFFFF'
+    ) {
+    }
+
+    public function getModuleSize(): int
+    {
+        return $this->moduleSize;
+    }
+
+    public function getMargin(): int
+    {
+        return $this->margin;
+    }
+
+    public function getForegroundColor(): string
+    {
+        return $this->foregroundColor;
+    }
+
+    public function getBackgroundColor(): string
+    {
+        return $this->backgroundColor;
+    }
+
+    public function withModuleSize(int $moduleSize): self
+    {
+        return new self(
+            $moduleSize,
+            $this->margin,
+            $this->foregroundColor,
+            $this->backgroundColor
+        );
+    }
+
+    public function withMargin(int $margin): self
+    {
+        return new self(
+            $this->moduleSize,
+            $margin,
+            $this->foregroundColor,
+            $this->backgroundColor
+        );
+    }
+
+    public function withColors(string $foreground, string $background): self
+    {
+        return new self(
+            $this->moduleSize,
+            $this->margin,
+            $foreground,
+            $background
+        );
+    }
+}
diff --git a/src/Domain/QrCode/ValueObject/QrCodeMatrix.php b/src/Domain/QrCode/ValueObject/QrCodeMatrix.php
new file mode 100644
index 00000000..ee24c9bf
--- /dev/null
+++ b/src/Domain/QrCode/ValueObject/QrCodeMatrix.php
@@ -0,0 +1,113 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Domain\QrCode\ValueObject;
+
+readonly class QrCodeMatrix
+{
+    public function __construct(
+        private array $matrix
+    ) {
+    }
+
+    public function getMatrix(): array
+    {
+        return $this->matrix;
+    }
+
+    public function getSize(): int
+    {
+        return count($this->matrix);
+    }
+
+    public function getModule(int $row, int $col): bool
+    {
+        return $this->matrix[$row][$col] ?? false;
+    }
+
+    public function toSvg(int $moduleSize = 4, int $margin = 4, string $foreground = '#000000', string $background = '#FFFFFF'): string
+    {
+        // Stellen Sie sicher, dass der Margin mindestens 4 Module beträgt (Quiet Zone)
+        $margin = max(4, $margin);
+
+        $size = $this->getSize();
+        $totalSize = ($size + 2 * $margin) * $moduleSize;
+
+        $svg = sprintf(
+            '<svg width="%d" height="%d" viewBox="0 0 %d %d" xmlns="http://www.w3.org/2000/svg">',
+            $totalSize, $totalSize, $totalSize, $totalSize
+        );
+
+        $svg .= sprintf('<rect width="100%%" height="100%%" fill="%s"/>', $background);
+
+        for ($row = 0; $row < $size; $row++) {
+            for ($col = 0; $col < $size; $col++) {
+                if ($this->getModule($row, $col)) {
+                    $x = ($col + $margin) * $moduleSize;
+                    $y = ($row + $margin) * $moduleSize;
+                    $svg .= sprintf(
+                        '<rect x="%d" y="%d" width="%d" height="%d" fill="%s"/>',
+                        $x, $y, $moduleSize, $moduleSize, $foreground
+                    );
+                }
+            }
+        }
+
+        $svg .= '</svg>';
+
+        return $svg;
+    }
+
+    public function toPng(int $moduleSize = 4, int $margin = 4): string
+    {
+        // Stellen Sie sicher, dass der Margin mindestens 4 Module beträgt (Quiet Zone)
+        $margin = max(4, $margin);
+
+        $size = $this->getSize();
+        $totalSize = ($size + 2 * $margin) * $moduleSize;
+
+        $image = imagecreate($totalSize, $totalSize);
+        $white = imagecolorallocate($image, 255, 255, 255);
+        $black = imagecolorallocate($image, 0, 0, 0);
+
+        imagefill($image, 0, 0, $white);
+
+        for ($row = 0; $row < $size; $row++) {
+            for ($col = 0; $col < $size; $col++) {
+                if ($this->getModule($row, $col)) {
+                    $x1 = ($col + $margin) * $moduleSize;
+                    $y1 = ($row + $margin) * $moduleSize;
+                    $x2 = $x1 + $moduleSize - 1;
+                    $y2 = $y1 + $moduleSize - 1;
+
+                    imagefilledrectangle($image, $x1, $y1, $x2, $y2, $black);
+                }
+            }
+        }
+
+        ob_start();
+        imagepng($image);
+        $pngData = ob_get_contents();
+        ob_end_clean();
+
+        imagedestroy($image);
+
+        return $pngData;
+    }
+
+    public function toAscii(): string
+    {
+        $size = $this->getSize();
+        $result = '';
+
+        for ($row = 0; $row < $size; $row++) {
+            for ($col = 0; $col < $size; $col++) {
+                $result .= $this->getModule($row, $col) ? '██' : '  ';
+            }
+            $result .= "\n";
+        }
+
+        return $result;
+    }
+}
diff --git a/src/Domain/QrCode/ValueObject/QrCodeMode.php b/src/Domain/QrCode/ValueObject/QrCodeMode.php
new file mode 100644
index 00000000..7ab7668a
--- /dev/null
+++ b/src/Domain/QrCode/ValueObject/QrCodeMode.php
@@ -0,0 +1,39 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Domain\QrCode\ValueObject;
+
+enum QrCodeMode: int
+{
+    case NUMERIC = 1;
+    case ALPHANUMERIC = 2;
+    case BYTE = 4;
+    case KANJI = 8;
+
+    public function getCharacterCountBits(QrCodeVersion $version): int
+    {
+        return match ($this) {
+            self::NUMERIC => match (true) {
+                $version->getValue() <= 9 => 10,
+                $version->getValue() <= 26 => 12,
+                default => 14,
+            },
+            self::ALPHANUMERIC => match (true) {
+                $version->getValue() <= 9 => 9,
+                $version->getValue() <= 26 => 11,
+                default => 13,
+            },
+            self::BYTE => match (true) {
+                $version->getValue() <= 9 => 8,
+                $version->getValue() <= 26 => 16,
+                default => 16,
+            },
+            self::KANJI => match (true) {
+                $version->getValue() <= 9 => 8,
+                $version->getValue() <= 26 => 10,
+                default => 12,
+            },
+        };
+    }
+}
diff --git a/src/Domain/QrCode/ValueObject/QrCodeVersion.php b/src/Domain/QrCode/ValueObject/QrCodeVersion.php
new file mode 100644
index 00000000..b4ef1623
--- /dev/null
+++ b/src/Domain/QrCode/ValueObject/QrCodeVersion.php
@@ -0,0 +1,166 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Domain\QrCode\ValueObject;
+
+use App\Domain\QrCode\Exception\QrCodeException;
+
+readonly class QrCodeVersion
+{
+    private int $version;
+
+    /**
+     * Datenbyte-Kapazität für QR-Codes (nach QR-Code-Spezifikation)
+     * Version => [L, M, Q, H] in Bytes
+     */
+    private const DATA_CAPACITY = [
+        // Version => [L, M, Q, H] (in Bytes)
+        1 => [19, 16, 13, 9],
+        2 => [34, 28, 22, 16],
+        3 => [55, 44, 34, 26],
+        4 => [80, 64, 48, 36],
+        5 => [108, 86, 62, 46],
+        6 => [136, 108, 76, 60],
+        7 => [156, 124, 88, 66],
+        8 => [194, 154, 110, 86],
+        9 => [232, 182, 132, 100],
+        10 => [274, 216, 154, 122],
+        11 => [324, 254, 180, 140],
+        12 => [370, 290, 206, 158],
+        13 => [428, 334, 244, 180],
+        14 => [461, 365, 261, 197],
+        15 => [523, 415, 295, 223],
+        16 => [589, 453, 325, 253],
+        17 => [647, 507, 367, 283],
+        18 => [721, 563, 397, 313],
+        19 => [795, 627, 445, 341],
+        20 => [861, 669, 485, 385],
+        21 => [932, 714, 512, 406],
+        22 => [1006, 782, 568, 442],
+        23 => [1094, 860, 614, 464],
+        24 => [1174, 914, 664, 514],
+        25 => [1276, 1000, 718, 538],
+        26 => [1370, 1062, 754, 596],
+        27 => [1468, 1128, 808, 628],
+        28 => [1531, 1193, 871, 661],
+        29 => [1631, 1267, 911, 701],
+        30 => [1735, 1373, 985, 745],
+        31 => [1843, 1455, 1033, 793],
+        32 => [1955, 1541, 1115, 845],
+        33 => [2071, 1631, 1171, 901],
+        34 => [2191, 1725, 1231, 961],
+        35 => [2306, 1812, 1286, 986],
+        36 => [2434, 1914, 1354, 1054],
+        37 => [2566, 1992, 1426, 1096],
+        38 => [2702, 2102, 1502, 1142],
+        39 => [2812, 2216, 1582, 1222],
+        40 => [2956, 2334, 1666, 1276],
+    ];
+
+    /**
+     * Kapazitätstabelle für Zeichen in verschiedenen Modi
+     * Dies sind Näherungswerte für die Anzahl der Zeichen
+     */
+    private const CHARACTER_CAPACITY = [
+        'numeric' => [ // Numerische Kapazität (nur Ziffern)
+            1 => [41, 34, 27, 17],
+            2 => [77, 63, 48, 34],
+            5 => [255, 202, 144, 106],
+            10 => [652, 513, 364, 288],
+            20 => [2061, 1600, 1156, 909],
+            30 => [4158, 3289, 2358, 1782],
+            40 => [7089, 5596, 3993, 3057],
+        ],
+        'alphanumeric' => [ // Alphanumerische Kapazität (Zahlen, Großbuchstaben, einige Symbole)
+            1 => [25, 20, 16, 10],
+            2 => [47, 38, 29, 20],
+            5 => [154, 122, 87, 64],
+            10 => [395, 311, 220, 174],
+            20 => [1249, 969, 701, 551],
+            30 => [2520, 1991, 1429, 1080],
+            40 => [4296, 3391, 2420, 1852],
+        ],
+        'byte' => [ // Byte-Kapazität (8-Bit-Bytes)
+            1 => [17, 14, 11, 7],
+            2 => [32, 26, 20, 14],
+            5 => [106, 84, 60, 44],
+            10 => [271, 213, 151, 119],
+            20 => [858, 666, 482, 378],
+            30 => [1732, 1370, 982, 742],
+            40 => [2953, 2331, 1663, 1273],
+        ],
+        'kanji' => [ // Kanji-Kapazität (Japanische Schriftzeichen)
+            1 => [10, 8, 7, 4],
+            2 => [20, 16, 12, 8],
+            5 => [65, 52, 37, 27],
+            10 => [167, 131, 93, 74],
+            20 => [528, 410, 297, 232],
+            30 => [1066, 841, 604, 457],
+            40 => [1817, 1435, 1024, 784],
+        ],
+    ];
+
+    public function __construct(int $version)
+    {
+        if ($version < 1 || $version > 40) {
+            throw new QrCodeException('QR Code Version muss zwischen 1 und 40 liegen');
+        }
+        $this->version = $version;
+    }
+
+    public function getValue(): int
+    {
+        return $this->version;
+    }
+
+    public function getSize(): int
+    {
+        return 21 + ($this->version - 1) * 4;
+    }
+
+    /**
+     * Liefert die Datenbyte-Kapazität für das angegebene Error-Correction-Level
+     */
+    public function getDataCapacity(ErrorCorrectionLevel $level): int
+    {
+        $index = match ($level) {
+            ErrorCorrectionLevel::L => 0,
+            ErrorCorrectionLevel::M => 1,
+            ErrorCorrectionLevel::Q => 2,
+            ErrorCorrectionLevel::H => 3,
+        };
+
+        return self::DATA_CAPACITY[$this->version][$index];
+    }
+
+    /**
+     * Gibt die Kapazität in Zeichen für einen bestimmten Kodierungsmodus zurück
+     */
+    public function getCharacterCapacity(string $mode, ErrorCorrectionLevel $level): int
+    {
+        if (!isset(self::CHARACTER_CAPACITY[$mode])) {
+            throw new QrCodeException("Unbekannter Kodierungsmodus: $mode");
+        }
+
+        $index = match ($level) {
+            ErrorCorrectionLevel::L => 0,
+            ErrorCorrectionLevel::M => 1,
+            ErrorCorrectionLevel::Q => 2,
+            ErrorCorrectionLevel::H => 3,
+        };
+
+        // Finde die nächste Version in der Kapazitätstabelle
+        $capacityVersion = $this->version;
+        while (!isset(self::CHARACTER_CAPACITY[$mode][$capacityVersion]) && $capacityVersion > 0) {
+            $capacityVersion--;
+        }
+
+        // Wenn keine passende Version gefunden wurde, verwende die niedrigste
+        if ($capacityVersion === 0) {
+            $capacityVersion = min(array_keys(self::CHARACTER_CAPACITY[$mode]));
+        }
+
+        return self::CHARACTER_CAPACITY[$mode][$capacityVersion][$index];
+    }
+}
diff --git a/src/Domain/User/Migrations/CreateUsersTable.php b/src/Domain/User/Migrations/CreateUsersTable.php
new file mode 100644
index 00000000..89030cb6
--- /dev/null
+++ b/src/Domain/User/Migrations/CreateUsersTable.php
@@ -0,0 +1,36 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Domain\User\Migrations;
+
+use App\Framework\Database\ConnectionInterface;
+use App\Framework\Database\Migration\Migration;
+
+final readonly class CreateUsersTable implements Migration
+{
+
+    public function up(ConnectionInterface $connection): void
+    {
+        $connection->query("CREATE TABLE IF NOT EXISTS users (
+                                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                                ulid BINARY(16) NOT NULL UNIQUE,
+                                name VARCHAR(255) NOT NULL
+                                 )"
+        );
+    }
+
+    public function down(ConnectionInterface $connection): void
+    {
+        $connection->query("DROP TABLE users");
+    }
+
+    public function getVersion(): string
+    {
+        return "001";
+    }
+
+    public function getDescription(): string
+    {
+        return "Create Users Table";
+    }
+}
diff --git a/src/Domain/User/User.php b/src/Domain/User/User.php
new file mode 100644
index 00000000..bc9bac2d
--- /dev/null
+++ b/src/Domain/User/User.php
@@ -0,0 +1,23 @@
+<?php
+
+namespace App\Domain\User;
+
+use App\Framework\Database\Attributes\Column;
+use App\Framework\Database\Attributes\Entity;
+
+#[Entity(tableName: 'users')]
+final readonly class User
+{
+    public function __construct(
+        #[Column(name: 'id', primary: true)]
+        public string $id,
+
+        #[Column(name: 'name')]
+        public string $name,
+
+        #public ?string $email = null,
+
+        /*#[Column(name: 'email')]
+        public string $email*/
+    ) {}
+}
diff --git a/src/Domain/ValueObjects/EmailAddress.php b/src/Domain/ValueObjects/EmailAddress.php
new file mode 100644
index 00000000..c732a812
--- /dev/null
+++ b/src/Domain/ValueObjects/EmailAddress.php
@@ -0,0 +1,31 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Domain\ValueObjects;
+
+final readonly class EmailAddress
+{
+    public function __construct(
+        public string $value
+    ) {
+        if (!filter_var($value, FILTER_VALIDATE_EMAIL)) {
+            throw new \InvalidArgumentException("Invalid email address: {$value}");
+        }
+    }
+
+    public function __toString(): string
+    {
+        return $this->value;
+    }
+
+    public function getDomain(): string
+    {
+        return substr($this->value, strpos($this->value, '@') + 1);
+    }
+
+    public function getLocalPart(): string
+    {
+        return substr($this->value, 0, strpos($this->value, '@'));
+    }
+}
diff --git a/src/Framework/Analytics/AnalyticsEvent.php b/src/Framework/Analytics/AnalyticsEvent.php
new file mode 100644
index 00000000..8b386a90
--- /dev/null
+++ b/src/Framework/Analytics/AnalyticsEvent.php
@@ -0,0 +1,89 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Analytics;
+
+final readonly class AnalyticsEvent
+{
+    public function __construct(
+        public string $type,
+        public string $name,
+        public array $data = [],
+        public array $context = [],
+        public ?string $userId = null,
+        public ?string $sessionId = null,
+        public ?\DateTimeImmutable $timestamp = null
+    ) {}
+
+    public static function pageView(string $path, array $context = []): self
+    {
+        return new self(
+            type: 'page_view',
+            name: $path,
+            context: $context,
+            timestamp: new \DateTimeImmutable()
+        );
+    }
+
+    public static function userAction(string $action, string $userId, array $data = []): self
+    {
+        return new self(
+            type: 'user_action',
+            name: $action,
+            data: $data,
+            userId: $userId,
+            timestamp: new \DateTimeImmutable()
+        );
+    }
+
+    public static function performance(string $metric, float $value, array $context = []): self
+    {
+        return new self(
+            type: 'performance',
+            name: $metric,
+            data: ['value' => $value],
+            context: $context,
+            timestamp: new \DateTimeImmutable()
+        );
+    }
+
+    public function withUserId(string $userId): self
+    {
+        return new self(
+            $this->type,
+            $this->name,
+            $this->data,
+            $this->context,
+            $userId,
+            $this->sessionId,
+            $this->timestamp
+        );
+    }
+
+    public function withSessionId(string $sessionId): self
+    {
+        return new self(
+            $this->type,
+            $this->name,
+            $this->data,
+            $this->context,
+            $this->userId,
+            $sessionId,
+            $this->timestamp
+        );
+    }
+
+    public function toArray(): array
+    {
+        return [
+            'type' => $this->type,
+            'name' => $this->name,
+            'data' => $this->data,
+            'context' => $this->context,
+            'user_id' => $this->userId,
+            'session_id' => $this->sessionId,
+            'timestamp' => $this->timestamp?->format(\DateTimeInterface::ATOM)
+        ];
+    }
+}
diff --git a/src/Framework/Analytics/AnalyticsInterface.php b/src/Framework/Analytics/AnalyticsInterface.php
new file mode 100644
index 00000000..3d043398
--- /dev/null
+++ b/src/Framework/Analytics/AnalyticsInterface.php
@@ -0,0 +1,20 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Analytics;
+
+interface AnalyticsInterface
+{
+    public function track(AnalyticsEvent $event): void;
+
+    public function trackPageView(string $path, array $context = []): void;
+
+    public function trackUserAction(string $action, string $userId, array $data = []): void;
+
+    public function trackPerformance(string $metric, float $value, array $context = []): void;
+
+    public function flush(): void;
+
+    public function isEnabled(): bool;
+}
diff --git a/src/Framework/Analytics/AnalyticsService.php b/src/Framework/Analytics/AnalyticsService.php
new file mode 100644
index 00000000..ac4c8c85
--- /dev/null
+++ b/src/Framework/Analytics/AnalyticsService.php
@@ -0,0 +1,111 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Analytics;
+
+use App\Framework\Queue\Queue;
+use App\Framework\Context\ExecutionContext;
+use App\Framework\Config\Configuration;
+
+final class AnalyticsService implements AnalyticsInterface
+{
+    private bool $enabled;
+    private array $context = [];
+
+    public function __construct(
+        private readonly Queue $queue,
+        private readonly ExecutionContext $executionContext,
+        private readonly Configuration $config
+    ) {
+        $this->enabled = $this->config->get('analytics.enabled', false);
+        $this->initializeContext();
+    }
+
+    public function track(AnalyticsEvent $event): void
+    {
+        #if (!$this->enabled) {
+        #    return;
+        #}
+
+        $enrichedEvent = $this->enrichEvent($event);
+
+        // Queue für asynchrone Verarbeitung
+        $this->queue->push('analytics', $enrichedEvent->toArray());
+    }
+
+    public function trackPageView(string $path, array $context = []): void
+    {
+        $this->track(AnalyticsEvent::pageView($path, array_merge($this->context, $context)));
+    }
+
+    public function trackUserAction(string $action, string $userId, array $data = []): void
+    {
+        $this->track(AnalyticsEvent::userAction($action, $userId, $data));
+    }
+
+    public function trackPerformance(string $metric, float $value, array $context = []): void
+    {
+        $this->track(AnalyticsEvent::performance($metric, $value, array_merge($this->context, $context)));
+    }
+
+    public function flush(): void
+    {
+        // Queue-basiert - kein explizites Flush nötig
+    }
+
+    public function isEnabled(): bool
+    {
+        return $this->enabled;
+    }
+
+    private function enrichEvent(AnalyticsEvent $event): AnalyticsEvent
+    {
+        $sessionId = $this->executionContext->getSessionId();
+        $userId = $this->executionContext->getUserId();
+
+        $enrichedEvent = $event;
+
+        if ($sessionId && !$event->sessionId) {
+            $enrichedEvent = $enrichedEvent->withSessionId($sessionId);
+        }
+
+        if ($userId && !$event->userId) {
+            $enrichedEvent = $enrichedEvent->withUserId($userId);
+        }
+
+        return $enrichedEvent;
+    }
+
+    private function initializeContext(): void
+    {
+        $this->context = [
+            'environment' => $this->config->get('app.environment', 'production'),
+            'version' => $this->config->get('app.version', '1.0.0'),
+            'user_agent' => $_SERVER['HTTP_USER_AGENT'] ?? null,
+            'ip_address' => $this->getClientIp(),
+        ];
+    }
+
+    private function getClientIp(): ?string
+    {
+        $headers = [
+            'HTTP_CF_CONNECTING_IP',
+            'HTTP_X_FORWARDED_FOR',
+            'HTTP_X_FORWARDED',
+            'HTTP_X_CLUSTER_CLIENT_IP',
+            'HTTP_FORWARDED_FOR',
+            'HTTP_FORWARDED',
+            'REMOTE_ADDR'
+        ];
+
+        foreach ($headers as $header) {
+            if (!empty($_SERVER[$header])) {
+                $ips = explode(',', $_SERVER[$header]);
+                return trim($ips[0]);
+            }
+        }
+
+        return null;
+    }
+}
diff --git a/src/Framework/Analytics/Middleware/AnalyticsMiddleware.php b/src/Framework/Analytics/Middleware/AnalyticsMiddleware.php
new file mode 100644
index 00000000..040b26b0
--- /dev/null
+++ b/src/Framework/Analytics/Middleware/AnalyticsMiddleware.php
@@ -0,0 +1,62 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Analytics\Middleware;
+
+use App\Framework\Analytics\AnalyticsInterface;
+use App\Framework\Analytics\AnalyticsService;
+use App\Framework\Config\Configuration;
+use App\Framework\Context\ExecutionContext;
+use App\Framework\Http\HttpMiddleware;
+use App\Framework\Http\MiddlewareContext;
+use App\Framework\Http\MiddlewarePriority;
+use App\Framework\Http\MiddlewarePriorityAttribute;
+use App\Framework\Http\RequestStateManager;
+use App\Framework\Performance\PerformanceMeter;
+use App\Framework\Queue\FileQueue;
+
+#[MiddlewarePriorityAttribute(MiddlewarePriority::BUSINESS_LOGIC)]
+final readonly class AnalyticsMiddleware implements HttpMiddleware
+{
+    private AnalyticsService $analytics;
+    public function __construct(
+        #private AnalyticsInterface $analytics = new AnalyticsService($queue, $executionContext, $config),
+        private ExecutionContext $executionContext,
+        private Configuration $config,
+        private PerformanceMeter $performanceMeter
+    ) {
+        $this->analytics = new AnalyticsService(new FileQueue(__DIR__.'/analytics-data'), $this->executionContext, $this->config);
+    }
+
+    public function __invoke(MiddlewareContext $context, callable $next, RequestStateManager $stateManager): MiddlewareContext
+    {
+        $startTime = microtime(true);
+
+
+        $request = $context->request;
+
+        // Track page view
+        /*$this->analytics->trackPageView(
+            $context->request->path,
+            [
+                'method' => $request->method->value,
+                'query_params' => $request->queryParams,
+                'referer' => $request->headers->get('Referer')
+            ]
+        );*/
+
+        $context = $next($context);
+
+        // Track response performance
+        $responseTime = (microtime(true) - $startTime) * 1000;
+
+        /*$this->analytics->trackPerformance('response_time', $responseTime, [
+            'path' => $request->path,
+            'method' => $request->method->value,
+            'status_code' => $context->response->status->value
+        ]);*/
+
+        return $context;
+    }
+}
diff --git a/src/Framework/Analytics/Queue/AnalyticsProcessor.php b/src/Framework/Analytics/Queue/AnalyticsProcessor.php
new file mode 100644
index 00000000..153ab4df
--- /dev/null
+++ b/src/Framework/Analytics/Queue/AnalyticsProcessor.php
@@ -0,0 +1,31 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Analytics\Queue;
+
+use App\Framework\Queue\QueueProcessor;
+use App\Framework\Analytics\Storage\AnalyticsStorageInterface;
+
+final readonly class AnalyticsProcessor implements QueueProcessor
+{
+    public function __construct(
+        private AnalyticsStorageInterface $storage
+    ) {}
+
+    public function canProcess(string $queue): bool
+    {
+        return $queue === 'analytics';
+    }
+
+    public function process(array $payload): void
+    {
+        $this->storage->store($payload);
+    }
+
+    public function failed(array $payload, \Throwable $exception): void
+    {
+        // Log failed analytics events
+        error_log("Analytics processing failed: " . $exception->getMessage());
+    }
+}
diff --git a/src/Framework/Analytics/Storage/AnalyticsStorageInterface.php b/src/Framework/Analytics/Storage/AnalyticsStorageInterface.php
new file mode 100644
index 00000000..3633d3dc
--- /dev/null
+++ b/src/Framework/Analytics/Storage/AnalyticsStorageInterface.php
@@ -0,0 +1,14 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Analytics\Storage;
+
+interface AnalyticsStorageInterface
+{
+    public function store(array $eventData): void;
+
+    public function query(array $filters = []): array;
+
+    public function aggregate(string $metric, array $filters = []): array;
+}
diff --git a/src/Framework/Analytics/Storage/FileAnalyticsStorage.php b/src/Framework/Analytics/Storage/FileAnalyticsStorage.php
new file mode 100644
index 00000000..a48c58fe
--- /dev/null
+++ b/src/Framework/Analytics/Storage/FileAnalyticsStorage.php
@@ -0,0 +1,68 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Analytics\Storage;
+
+final class FileAnalyticsStorage implements AnalyticsStorageInterface
+{
+    public function __construct(
+        private readonly string $storagePath
+    ) {
+        if (!is_dir($this->storagePath)) {
+            mkdir($this->storagePath, 0755, true);
+        }
+    }
+
+    public function store(array $eventData): void
+    {
+        $date = date('Y-m-d');
+        $filename = $this->storagePath . "/analytics-{$date}.jsonl";
+
+        $line = json_encode($eventData) . "\n";
+        file_put_contents($filename, $line, FILE_APPEND | LOCK_EX);
+    }
+
+    public function query(array $filters = []): array
+    {
+        // Einfache Implementation - kann erweitert werden
+        $files = glob($this->storagePath . '/analytics-*.jsonl');
+        $events = [];
+
+        foreach ($files as $file) {
+            $lines = file($file, FILE_IGNORE_NEW_LINES);
+            foreach ($lines as $line) {
+                $event = json_decode($line, true);
+                if ($this->matchesFilters($event, $filters)) {
+                    $events[] = $event;
+                }
+            }
+        }
+
+        return $events;
+    }
+
+    public function aggregate(string $metric, array $filters = []): array
+    {
+        $events = $this->query($filters);
+
+        // Einfache Aggregation - kann erweitert werden
+        $aggregated = [];
+        foreach ($events as $event) {
+            $key = $event['type'] ?? 'unknown';
+            $aggregated[$key] = ($aggregated[$key] ?? 0) + 1;
+        }
+
+        return $aggregated;
+    }
+
+    private function matchesFilters(array $event, array $filters): bool
+    {
+        foreach ($filters as $key => $value) {
+            if (!isset($event[$key]) || $event[$key] !== $value) {
+                return false;
+            }
+        }
+        return true;
+    }
+}
diff --git a/src/Framework/Api/ApiException.php b/src/Framework/Api/ApiException.php
new file mode 100644
index 00000000..850b4794
--- /dev/null
+++ b/src/Framework/Api/ApiException.php
@@ -0,0 +1,32 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Api;
+
+use App\Framework\HttpClient\ClientResponse;
+use RuntimeException;
+
+class ApiException extends RuntimeException
+{
+    public function __construct(
+        string $message,
+        int $code,
+        private readonly ClientResponse $response
+    ) {
+        parent::__construct($message, $code);
+    }
+
+    public function getResponse(): ClientResponse
+    {
+        return $this->response;
+    }
+
+    public function getResponseData(): ?array
+    {
+        try {
+            return json_decode($this->response->body, true, 512, JSON_THROW_ON_ERROR);
+        } catch (\JsonException) {
+            return null;
+        }
+    }
+}
diff --git a/src/Framework/Api/ApiRequestTrait.php b/src/Framework/Api/ApiRequestTrait.php
new file mode 100644
index 00000000..44b551b4
--- /dev/null
+++ b/src/Framework/Api/ApiRequestTrait.php
@@ -0,0 +1,93 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Api;
+
+use App\Framework\Http\Method;
+use App\Framework\HttpClient\ClientOptions;
+use App\Framework\HttpClient\ClientRequest;
+use App\Framework\HttpClient\ClientResponse;
+use App\Framework\HttpClient\CurlHttpClient;
+use App\Framework\HttpClient\HttpClient;
+
+trait ApiRequestTrait
+{
+    private string $baseUrl;
+    private ClientOptions $defaultOptions;
+    private HttpClient $httpClient;
+
+    /**
+     * Sendet eine Anfrage an die API
+     */
+    public function sendRequest(
+        Method         $method,
+        string         $endpoint,
+        array          $data = [],
+        ?ClientOptions $options = null
+    ): ClientResponse {
+        $url = $this->baseUrl . '/' . ltrim($endpoint, '/');
+        $options = $options ?? $this->defaultOptions;
+
+        $request = ClientRequest::json(
+            method: $method,
+            url: $url,
+            data: $data,
+            options: $options
+        );
+
+        $response = $this->httpClient->send($request);
+
+        $this->handleResponseErrors($response);
+
+        return $response;
+    }
+
+    /**
+     * Verarbeitet Fehler in der API-Antwort
+     */
+    private function handleResponseErrors(ClientResponse $response): void
+    {
+        if ($response->status->value < 400) {
+            return;
+        }
+
+        $responseData = json_decode($response->body, true) ?: [];
+
+        throw new ApiException(
+            $this->formatErrorMessage($responseData),
+            $response->status->value,
+            $response
+        );
+    }
+
+    /**
+     * Formatiert eine benutzerfreundliche Fehlermeldung
+     */
+    private function formatErrorMessage(array $responseData): string
+    {
+        $errorMessage = 'API-Fehler';
+
+        if (isset($responseData['detail'])) {
+            $errorMessage .= ': ' . $responseData['detail'];
+
+            if (isset($responseData['validation_messages'])) {
+                $errorMessage .= ' - Validierungsfehler: ' . json_encode(
+                    $responseData['validation_messages'],
+                    JSON_UNESCAPED_UNICODE
+                );
+            }
+        } elseif (isset($responseData['error'])) {
+            $errorMessage .= ': ' . $responseData['error'];
+        }
+
+        return $errorMessage;
+    }
+
+    /**
+     * Dekodiert den Response-Body als JSON
+     */
+    protected function decodeJson(ClientResponse $response): array
+    {
+        return json_decode($response->body, true) ?: [];
+    }
+}
diff --git a/src/Framework/Attributes/Route.php b/src/Framework/Attributes/Route.php
index 883ab03f..191f951d 100644
--- a/src/Framework/Attributes/Route.php
+++ b/src/Framework/Attributes/Route.php
@@ -4,15 +4,16 @@ declare(strict_types=1);
 
 namespace App\Framework\Attributes;
 
+use App\Framework\Http\Method;
 use Attribute;
 
-#[Attribute(\Attribute::TARGET_METHOD, \Attribute::IS_REPEATABLE)]
-
-class Route
+#[Attribute(Attribute::TARGET_METHOD | Attribute::IS_REPEATABLE)]
+final readonly class Route
 {
     public function __construct(
         public string $path,
-        public string $method = 'GET',
+        public Method $method = Method::GET,
+        public ?string $name = null,
     ) {
     }
 }
diff --git a/src/Framework/Attributes/StaticPage.php b/src/Framework/Attributes/StaticPage.php
new file mode 100644
index 00000000..6e43059a
--- /dev/null
+++ b/src/Framework/Attributes/StaticPage.php
@@ -0,0 +1,20 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Attributes;
+
+/**
+ * Kennzeichnet eine Controller-Methode, deren Route als statische Seite generiert werden soll.
+ */
+#[\Attribute(\Attribute::TARGET_METHOD, \Attribute::IS_REPEATABLE)]
+final class StaticPage
+{
+    /**
+     * @param string|null $outputPath Optionaler benutzerdefinierter Ausgabepfad für die statische Seite
+     * @param bool $prerender Ob die Seite beim Deployment vorgerendert werden soll
+     */
+    public function __construct(
+        public ?string $outputPath = null,
+        public bool $prerender = true
+    ) {}
+}
diff --git a/src/Framework/Auth/Auth.php b/src/Framework/Auth/Auth.php
new file mode 100644
index 00000000..a3d1a797
--- /dev/null
+++ b/src/Framework/Auth/Auth.php
@@ -0,0 +1,11 @@
+<?php
+
+namespace App\Framework\Auth;
+
+use Attribute;
+
+#[Attribute(Attribute::TARGET_METHOD|Attribute::IS_REPEATABLE)]
+class Auth
+{
+
+}
diff --git a/src/Framework/Auth/AuthMapper.php b/src/Framework/Auth/AuthMapper.php
new file mode 100644
index 00000000..801d7a98
--- /dev/null
+++ b/src/Framework/Auth/AuthMapper.php
@@ -0,0 +1,21 @@
+<?php
+
+namespace App\Framework\Auth;
+
+use App\Framework\Core\AttributeMapper;
+
+final readonly class AuthMapper implements AttributeMapper
+{
+    public function getAttributeClass(): string
+    {
+        return Auth::class;
+    }
+
+    public function map(object $reflectionTarget, object $attributeInstance): ?array
+    {
+        return [
+            'class' => $reflectionTarget->getDeclaringClass()->getName(),
+            'method' => $reflectionTarget->getName(),
+        ];
+    }
+}
diff --git a/src/Framework/Cache/Cache.php b/src/Framework/Cache/Cache.php
new file mode 100644
index 00000000..85f19f4b
--- /dev/null
+++ b/src/Framework/Cache/Cache.php
@@ -0,0 +1,18 @@
+<?php
+
+namespace App\Framework\Cache;
+
+interface Cache
+{
+    public function get(string $key): CacheItem;
+    public function set(string $key, mixed $value, ?int $ttl = null): bool;
+    public function has(string $key): bool;
+    public function forget(string $key): bool;
+    public function clear(): bool;
+
+    /**
+     * Führt Callback aus, wenn Wert nicht im Cache ist ("Remember"-Pattern)
+     * und cached das Ergebnis für die gewünschte Zeit
+     */
+    public function remember(string $key, callable $callback, int $ttl = 3600): CacheItem;
+}
diff --git a/src/Framework/Cache/CacheDecorator.php b/src/Framework/Cache/CacheDecorator.php
new file mode 100644
index 00000000..58fb5843
--- /dev/null
+++ b/src/Framework/Cache/CacheDecorator.php
@@ -0,0 +1,32 @@
+<?php
+
+namespace App\Framework\Cache;
+
+use ReflectionException;
+use ReflectionMethod;
+
+final readonly class CacheDecorator
+{
+    public function __construct(
+        private object $service,
+        private Cache  $cache
+    ) {}
+
+    /**
+     * @throws ReflectionException
+     */
+    public function __call(string $name, array $args)
+    {
+        $method = new ReflectionMethod($this->service, $name);
+        $attrs = $method->getAttributes(Cacheable::class);
+
+        if ($attrs) {
+            $attr = $attrs[0]->newInstance();
+            $key = $attr->key ?? $method->getName() . ':' . md5(serialize($args));
+            $ttl = $attr->ttl ?? 3600;
+            return $this->cache->remember($key, fn() => $method->invokeArgs($this->service, $args), $ttl);
+        }
+
+        return $method->invokeArgs($this->service, $args);
+    }
+}
diff --git a/src/Framework/Cache/CacheDriver.php b/src/Framework/Cache/CacheDriver.php
new file mode 100644
index 00000000..91c388e1
--- /dev/null
+++ b/src/Framework/Cache/CacheDriver.php
@@ -0,0 +1,12 @@
+<?php
+
+namespace App\Framework\Cache;
+
+interface CacheDriver
+{
+    public function get(string $key): CacheItem;
+    public function set(string $key, string $value, ?int $ttl = null): bool;
+    public function has(string $key): bool;
+    public function forget(string $key): bool;
+    public function clear(): bool;
+}
diff --git a/src/Framework/Cache/CacheInitializer.php b/src/Framework/Cache/CacheInitializer.php
new file mode 100644
index 00000000..760d5526
--- /dev/null
+++ b/src/Framework/Cache/CacheInitializer.php
@@ -0,0 +1,70 @@
+<?php
+
+namespace App\Framework\Cache;
+
+use App\Framework\Cache\Compression\GzipCompression;
+use App\Framework\Cache\Compression\NullCompression;
+use App\Framework\Cache\Driver\ApcuCache;
+use App\Framework\Cache\Driver\FileCache;
+use App\Framework\Cache\Driver\InMemoryCache;
+use App\Framework\Cache\Driver\NullCache;
+use App\Framework\Cache\Driver\RedisCache;
+use App\Framework\Cache\Serializer\JsonSerializer;
+use App\Framework\Cache\Serializer\PhpSerializer;
+use App\Framework\DI\Initializer;
+
+final readonly class CacheInitializer
+{
+    public function __construct(
+        private string $redisHost = 'redis',
+        private int    $redisPort = 6379,
+        private int    $compressionLevel = -1,
+        private int    $minCompressionLength = 1024
+    ) {}
+
+    #[Initializer]
+    public function __invoke(): Cache
+    {
+        $this->clear();
+
+        $serializer = new PhpSerializer();
+        $serializer = new JsonSerializer();
+        $compression = new GzipCompression($this->compressionLevel, $this->minCompressionLength);
+
+
+        // L1 Cache:
+        if(function_exists('apcu_clear_cache')) {
+            $apcuCache  = new GeneralCache(new APCuCache);
+        }else {
+            $apcuCache  = new GeneralCache(new InMemoryCache);
+        }
+
+        $compressedApcuCache = new CompressionCacheDecorator(
+            $apcuCache,
+            $compression,
+            $serializer
+        );
+
+        // L2 Cache:
+        $redisCache  = new GeneralCache(new RedisCache(host: $this->redisHost, port: $this->redisPort));
+        $compressedRedisCache = new CompressionCacheDecorator(
+            $redisCache,
+            $compression,
+            $serializer
+        );
+
+        $multiLevelCache = new MultiLevelCache($compressedApcuCache, $compressedRedisCache);
+
+        #return $multiLevelCache;
+
+        return new LoggingCacheDecorator($multiLevelCache);
+
+
+        #return new GeneralCache(new NullCache());
+    }
+
+    private function clear(): void
+    {
+        apcu_clear_cache();
+    }
+}
diff --git a/src/Framework/Cache/CacheItem.php b/src/Framework/Cache/CacheItem.php
new file mode 100644
index 00000000..da19a1d6
--- /dev/null
+++ b/src/Framework/Cache/CacheItem.php
@@ -0,0 +1,21 @@
+<?php
+namespace App\Framework\Cache;
+
+final readonly class CacheItem
+{
+    private function __construct(
+        public string $key,
+        public mixed $value,
+        public bool $isHit,
+    ) {}
+
+    public static function miss(string $key): self
+    {
+        return new self($key, null, false);
+    }
+
+    public static function hit(string $key, mixed $value): self
+    {
+        return new self($key, $value, true);
+    }
+}
diff --git a/src/Framework/Cache/CachePrefix.php b/src/Framework/Cache/CachePrefix.php
new file mode 100644
index 00000000..57586e8a
--- /dev/null
+++ b/src/Framework/Cache/CachePrefix.php
@@ -0,0 +1,12 @@
+<?php
+
+namespace App\Framework\Cache;
+
+enum CachePrefix: string
+{
+    case GENERAL = 'cache:';
+
+    case QUERY = 'query_cache:';
+
+    #case SESSION = 'session:';
+}
diff --git a/src/Framework/Cache/Cacheable.php b/src/Framework/Cache/Cacheable.php
new file mode 100644
index 00000000..79166456
--- /dev/null
+++ b/src/Framework/Cache/Cacheable.php
@@ -0,0 +1,15 @@
+<?php
+
+namespace App\Framework\Cache;
+
+#[\Attribute(\Attribute::TARGET_METHOD)]
+final class Cacheable
+{
+    /**
+     * @param string|null $key Template z.B.: "user:profile:{id}"
+     */
+    public function __construct(
+        public ?string $key = null,
+        public int $ttl = 3600,
+    ) {}
+}
diff --git a/src/Framework/Cache/Commands/ClearCache.php b/src/Framework/Cache/Commands/ClearCache.php
new file mode 100644
index 00000000..8686c345
--- /dev/null
+++ b/src/Framework/Cache/Commands/ClearCache.php
@@ -0,0 +1,23 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Cache\Commands;
+
+use App\Framework\Cache\Cache;
+use App\Framework\Console\ConsoleCommand;
+use App\Framework\Console\ConsoleInput;
+use App\Framework\Console\ConsoleOutput;
+
+final readonly class ClearCache
+{
+    public function __construct(
+        private Cache $cache,
+    ) {}
+
+    #[ConsoleCommand("cache:clear", "Clears the cache")]
+    public function __invoke(ConsoleInput $input, ConsoleOutput $output): void
+    {
+        $this->cache->clear();
+        $output->writeSuccess("Cache cleared");
+    }
+}
diff --git a/src/Framework/Cache/Compression/GzipCompression.php b/src/Framework/Cache/Compression/GzipCompression.php
new file mode 100644
index 00000000..ce581f6e
--- /dev/null
+++ b/src/Framework/Cache/Compression/GzipCompression.php
@@ -0,0 +1,46 @@
+<?php
+
+namespace App\Framework\Cache\Compression;
+
+use App\Framework\Cache\CompressionAlgorithm;
+
+final class GzipCompression implements CompressionAlgorithm
+{
+    private const string PREFIX = 'gz:';
+    private int $level;
+    private int $threshold;
+
+    public function __construct(int $compressionLevel = -1, int $minLengthToCompress = 1024)
+    {
+        $this->level = $compressionLevel;
+        $this->threshold = $minLengthToCompress;
+    }
+
+    public function compress(string $value, bool $forceCompression = false): string
+    {
+        if (!$forceCompression && strlen($value) < $this->threshold) {
+            return $value;
+        }
+        $compressed = gzcompress($value, $this->level);
+        if ($compressed === false) {
+            // Fallback auf Originalwert bei Fehler
+            return $value;
+        }
+        return self::PREFIX . $compressed;
+    }
+
+    public function decompress(string $value): string
+    {
+        if (!$this->isCompressed($value)) {
+            return $value;
+        }
+        $raw = substr($value, strlen(self::PREFIX));
+        $decompressed = @gzuncompress($raw);
+        return $decompressed !== false ? $decompressed : $value;
+    }
+
+    public function isCompressed(string $value): bool
+    {
+        return strncmp($value, self::PREFIX, strlen(self::PREFIX)) === 0;
+    }
+}
diff --git a/src/Framework/Cache/Compression/NullCompression.php b/src/Framework/Cache/Compression/NullCompression.php
new file mode 100644
index 00000000..56d84e4f
--- /dev/null
+++ b/src/Framework/Cache/Compression/NullCompression.php
@@ -0,0 +1,23 @@
+<?php
+
+namespace App\Framework\Cache\Compression;
+
+use App\Framework\Cache\CompressionAlgorithm;
+
+final class NullCompression implements CompressionAlgorithm
+{
+    public function compress(string $value, bool $forceCompression = false): string
+    {
+        return $value; // Keine Komprimierung
+    }
+
+    public function decompress(string $value): string
+    {
+        return $value; // Keine Dekomprimierung
+    }
+
+    public function isCompressed(string $value): bool
+    {
+        return false; // Nie komprimiert
+    }
+}
diff --git a/src/Framework/Cache/CompressionAlgorithm.php b/src/Framework/Cache/CompressionAlgorithm.php
new file mode 100644
index 00000000..5efb28c8
--- /dev/null
+++ b/src/Framework/Cache/CompressionAlgorithm.php
@@ -0,0 +1,22 @@
+<?php
+
+namespace App\Framework\Cache;
+
+interface CompressionAlgorithm
+{
+    /**
+     * Komprimiert einen Wert. Rückgabe kann String oder Binärdaten sein.
+     * Gibt bei $forceCompression ein Flag an, ob immer komprimiert werden soll.
+     */
+    public function compress(string $value, bool $forceCompression = false): string;
+
+    /**
+     * Dekodiert einen Wert, falls komprimiert; ansonsten unverändert zurückgeben.
+     */
+    public function decompress(string $value): string;
+
+    /**
+     * Gibt true zurück, falls $value komprimiert ist (z.B. am Prefix erkennbar)
+     */
+    public function isCompressed(string $value): bool;
+}
diff --git a/src/Framework/Cache/CompressionCacheDecorator.php b/src/Framework/Cache/CompressionCacheDecorator.php
new file mode 100644
index 00000000..2e21825b
--- /dev/null
+++ b/src/Framework/Cache/CompressionCacheDecorator.php
@@ -0,0 +1,168 @@
+<?php
+
+namespace App\Framework\Cache;
+
+final readonly class CompressionCacheDecorator implements Cache
+{
+    public function __construct(
+        private Cache                $innerCache,
+        private CompressionAlgorithm $algorithm,
+        private Serializer           $serializer
+    ) {}
+
+    public function get(string $key): CacheItem
+    {
+        $item = $this->innerCache->get($key);
+        if (!$item->isHit || !is_string($item->value)) {
+            return $item;
+        }
+
+        $value = $item->value;
+
+        if ($this->algorithm->isCompressed($value)) {
+            $value = $this->algorithm->decompress($value);
+        }
+
+        try {
+            // Versuche direkt zu deserialisieren.
+            // Schlägt dies fehl, wird der rohe (aber dekomprimierte) Wert zurückgegeben.
+            $unserialized = $this->serializer->unserialize($value);
+            return CacheItem::hit($key, $unserialized);
+        } catch (\Throwable $e) {
+            // Das ist ein erwartetes Verhalten, wenn der Wert ein einfacher String war.
+            // Optional: Loggen des Fehlers für Debugging-Zwecke.
+            // error_log("CompressionCacheDecorator: Deserialization failed for key: {$key}. Assuming raw value.");
+            return CacheItem::hit($key, $value);
+        }
+
+        //LEGACY:
+
+        /*if ($this->algorithm->isCompressed($item->value)) {
+            $decompressed = $this->algorithm->decompress($item->value);
+
+            // Prüfe ob der Inhalt serialisiert wurde
+            if ($this->isSerialized($decompressed)) {
+                try {
+                    $unserialized = $this->serializer->unserialize($decompressed);
+                    return CacheItem::hit($key, $unserialized);
+                } catch (\Throwable $e) {
+                    // Fallback bei Deserialisierung-Fehler
+                    error_log("CompressionCacheDecorator: Deserialization failed for key: {$key}, Error: " . $e->getMessage());
+                }
+            }
+
+            // Wenn nicht serialisiert oder Deserialisierung fehlgeschlagen, gib dekomprimierten String zurück
+            return CacheItem::hit($key, $decompressed);
+        }
+
+        if($this->isSerialized($item->value)) {
+            try {
+                $unserialized = $this->serializer->unserialize($item->value);
+                return CacheItem::hit($key, $unserialized);
+            } catch (\Throwable $e) {
+                error_log("CompressionCacheDecorator: Deserialization failed for key: {$key}, Error: " . $e->getMessage());
+            }
+        }
+
+        return $item;*/
+    }
+
+    public function set(string $key, mixed $value, ?int $ttl = null): bool
+    {
+        if (!is_string($value)) {
+            $value = $this->serializer->serialize($value);
+        }
+        $compressed = $this->algorithm->compress($value);
+        return $this->innerCache->set($key, $compressed, $ttl);
+    }
+
+    public function has(string $key): bool
+    {
+        return $this->innerCache->has($key);
+    }
+
+    public function forget(string $key): bool
+    {
+        return $this->innerCache->forget($key);
+    }
+
+    public function clear(): bool
+    {
+        return $this->innerCache->clear();
+    }
+
+    public function remember(string $key, callable $callback, int $ttl = 3600): CacheItem
+    {
+        $item = $this->get($key);
+        if ($item->isHit) {
+            return $item;
+        }
+        $value = $callback();
+        $this->set($key, $value, $ttl);
+        return CacheItem::hit($key, $value);
+    }
+
+    /**
+     * Prüft ob ein String serialisierte PHP-Daten enthält
+     */
+    /*
+    private function isSerialized(string $data): bool
+    {
+        // Leere Strings oder sehr kurze Strings können nicht serialisiert sein
+        if (strlen($data) < 4) {
+            return false;
+        }
+
+        // Prüfe auf NULL-Wert (serialisiert als 'N;')
+        if ($data === 'N;') {
+            return true;
+        }
+
+        // Prüfe auf boolean false (serialisiert als 'b:0;')
+        if ($data === 'b:0;') {
+            return true;
+        }
+
+        // Prüfe auf boolean true (serialisiert als 'b:1;')
+        if ($data === 'b:1;') {
+            return true;
+        }
+
+        // Prüfe auf typische serialize() Patterns:
+        // a:N: (array mit N Elementen)
+        // s:N: (string mit N Zeichen)
+        // i:N; (integer mit Wert N)
+        // d:N; (double/float mit Wert N)
+        // O:N: (object mit Klassennamen der Länge N)
+        // b:N; (boolean mit Wert N)
+        // r:N; (reference)
+        // R:N; (reference)
+        if (preg_match('/^[asdObRr]:[0-9]+[:|;]/', $data)) {
+            return true;
+        }
+
+        // Prüfe auf integer Pattern: i:Zahl;
+        if (preg_match('/^i:-?[0-9]+;/', $data)) {
+            return true;
+        }
+
+        // Prüfe auf float Pattern: d:Zahl;
+        if (preg_match('/^d:-?[0-9]*\.?[0-9]+([eE][-+]?[0-9]+)?;/', $data)) {
+            return true;
+        }
+
+        // Zusätzliche Validierung: Versuche tatsächlich zu deserialisieren
+        // aber nur bei verdächtigen Patterns, um Performance zu schonen
+        if (strlen($data) < 1000 && (
+            str_starts_with($data, 'a:') ||
+            str_starts_with($data, 'O:') ||
+            str_starts_with($data, 's:')
+        )) {
+            $test = @unserialize($data);
+            return $test !== false || $data === 'b:0;';
+        }
+
+        return false;
+    }
+    */
+}
diff --git a/src/Framework/Cache/Driver/ApcuCache.php b/src/Framework/Cache/Driver/ApcuCache.php
new file mode 100644
index 00000000..b5605e1e
--- /dev/null
+++ b/src/Framework/Cache/Driver/ApcuCache.php
@@ -0,0 +1,57 @@
+<?php
+
+namespace App\Framework\Cache\Driver;
+
+use App\Framework\Cache\CacheDriver;
+use App\Framework\Cache\CacheItem;
+
+final readonly class ApcuCache implements CacheDriver
+{
+
+    public function __construct(
+        private string $prefix = 'cache:'
+    ){}
+
+    private function prefixKey(string $key): string
+    {
+        return $this->prefix . $key;
+    }
+
+    public function get(string $key): CacheItem
+    {
+        $key = $this->prefixKey($key);
+
+        $success = false;
+        $value = apcu_fetch($key, $success);
+        if (!$success) {
+            return CacheItem::miss($key);
+        }
+
+        return CacheItem::hit($key, $value);
+    }
+
+    public function set(string $key, string $value, ?int $ttl = null): bool
+    {
+        $key = $this->prefixKey($key);
+        $ttl = $ttl ?? 0;
+
+        return apcu_store($key, $value, $ttl);
+    }
+
+    public function has(string $key): bool
+    {
+        $key = $this->prefixKey($key);
+        return apcu_exists($key);
+    }
+
+    public function forget(string $key): bool
+    {
+        $key = $this->prefixKey($key);
+        return apcu_delete($key);
+    }
+
+    public function clear(): bool
+    {
+        return apcu_clear_cache();
+    }
+}
diff --git a/src/Framework/Cache/Driver/FileCache.php b/src/Framework/Cache/Driver/FileCache.php
new file mode 100644
index 00000000..4a993c7a
--- /dev/null
+++ b/src/Framework/Cache/Driver/FileCache.php
@@ -0,0 +1,154 @@
+<?php
+
+namespace App\Framework\Cache\Driver;
+
+use App\Framework\Cache\CacheDriver;
+use App\Framework\Cache\CacheItem;
+use App\Framework\Filesystem\FileStorage;
+use App\Framework\Filesystem\Storage;
+
+final readonly class FileCache implements CacheDriver
+{
+    private const string CACHE_PATH = __DIR__ . '/../storage/cache';
+
+    public function __construct(
+        private Storage $fileSystem = new FileStorage(),
+    ) {
+        $this->fileSystem->createDirectory(self::CACHE_PATH);
+    }
+
+    private function getFileName(string $key, ?int $expiresAt): string
+    {
+        // Schütze vor Pfad/komischen Zeichen und Hash den Key
+        $safeKey = preg_replace('/[^a-zA-Z0-9_\-]/', '_', $key);
+
+        $hash = md5($safeKey);
+
+        return self::CACHE_PATH . DIRECTORY_SEPARATOR . $hash .'_'. ($expiresAt ?? 0) . '.cache.php';
+    }
+
+    private function getFilesForKey(string $key): array
+    {
+        $hash = md5($key);
+
+        $pattern = self::CACHE_PATH . DIRECTORY_SEPARATOR . $hash . '*.cache.php';
+
+        return glob($pattern) ?: [];
+    }
+
+    private function getLockFileName(string $key): string
+    {
+        $hash = md5($key);
+        return self::CACHE_PATH . DIRECTORY_SEPARATOR . $hash . '.lock';
+    }
+
+    private function withKeyLock(string $key, callable $callback)
+    {
+        $lockFile = fopen($this->getLockFileName($key), 'c');
+        if ($lockFile === false) {
+            // Optional: Fehler werfen oder Logging
+            return $callback(null);
+        }
+
+        try {
+            // Exklusiven Lock setzen, Wartezeit begrenzen wenn gewünscht
+            if (flock($lockFile, LOCK_EX)) {
+                return $callback($lockFile);
+            }
+            // Lock konnte nicht gesetzt werden
+            return $callback(null);
+        } finally {
+            flock($lockFile, LOCK_UN);
+            fclose($lockFile);
+        }
+    }
+
+
+    public function get(string $key): CacheItem
+    {
+        $bestFile = null;
+        $bestExpires = null;
+
+        foreach($this->getFilesForKey($key) as $file) {
+            if (!preg_match('/_(\d+)\.cache\.php$/', $file, $m)) {
+                continue;
+            }
+            $expiresAt = (int)$m[1];
+            if ($expiresAt > 0 && $expiresAt < time()) {
+                $this->fileSystem->delete($file);
+                continue;
+            }
+            if ($bestFile === null || $expiresAt > $bestExpires) {
+                $bestFile = $file;
+                $bestExpires = $expiresAt;
+            }
+        }
+
+        if ($bestFile === null) {
+            return CacheItem::miss($key);
+        }
+
+        $content = $this->fileSystem->get($bestFile);
+
+        $data = @unserialize($content) ?: [];
+
+
+        if (!isset($data['value'])) {
+            $this->fileSystem->delete($bestFile);
+            return CacheItem::miss($key);
+        }
+
+        return CacheItem::hit($key, $data['value']);
+
+    }
+
+    public function set(string $key, mixed $value, ?int $ttl = null): bool
+    {
+        return $this->withKeyLock($key, function () use ($key, $value, $ttl) {
+
+            $expiresAt = $ttl ? (time() + $ttl) : null;
+
+            foreach ($this->getFilesForKey($key) as $file) {
+                $this->fileSystem->delete($file);
+            }
+
+            $file = $this->getFileName($key, $expiresAt);
+
+            $data = [
+                'value' => $value,
+                'expires_at' => $expiresAt,
+            ];
+
+            $this->fileSystem->put($file, serialize($data));
+
+            return true;
+        });
+    }
+
+    public function has(string $key): bool
+    {
+        $item = $this->get($key);
+        return $item->isHit;
+    }
+
+    public function forget(string $key): bool
+    {
+        return $this->withKeyLock($key, function () use ($key) {
+
+            foreach ($this->getFilesForKey($key) as $file) {
+                $this->fileSystem->delete($file);
+            }
+            return true;
+        });
+    }
+
+    public function clear(): bool
+    {
+        $files = glob(self::CACHE_PATH . '*.cache.php') ?: [];
+        foreach ($files as $file) {
+            $this->fileSystem->delete($file);
+        }
+
+        return true;
+    }
+}
diff --git a/src/Framework/Cache/Driver/InMemoryCache.php b/src/Framework/Cache/Driver/InMemoryCache.php
new file mode 100644
index 00000000..98cd68d7
--- /dev/null
+++ b/src/Framework/Cache/Driver/InMemoryCache.php
@@ -0,0 +1,39 @@
+<?php
+
+namespace App\Framework\Cache\Driver;
+
+use App\Framework\Cache\CacheDriver;
+use App\Framework\Cache\CacheItem;
+
+final class InMemoryCache implements CacheDriver
+{
+    private array $data = [];
+
+    public function get(string $key): CacheItem
+    {
+        return $this->data[$key] ?? CacheItem::miss($key);
+    }
+
+    public function set(string $key, string $value, ?int $ttl = null): bool
+    {
+        $this->data[$key] = $value;
+        return true;
+    }
+
+    public function has(string $key): bool
+    {
+        return isset($this->data[$key]);
+    }
+
+    public function forget(string $key): bool
+    {
+        unset($this->data[$key]);
+        return true;
+    }
+
+    public function clear(): bool
+    {
+        unset($this->data);
+        return true;
+    }
+}
diff --git a/src/Framework/Cache/Driver/NullCache.php b/src/Framework/Cache/Driver/NullCache.php
new file mode 100644
index 00000000..bcfed443
--- /dev/null
+++ b/src/Framework/Cache/Driver/NullCache.php
@@ -0,0 +1,35 @@
+<?php
+
+namespace App\Framework\Cache\Driver;
+
+use App\Framework\Cache\CacheDriver;
+use App\Framework\Cache\CacheItem;
+
+class NullCache implements CacheDriver
+{
+
+    public function get(string $key): CacheItem
+    {
+        return CacheItem::miss($key);
+    }
+
+    public function set(string $key, string $value, ?int $ttl = null): bool
+    {
+        return true;
+    }
+
+    public function has(string $key): bool
+    {
+        return false;
+    }
+
+    public function forget(string $key): bool
+    {
+        return true;
+    }
+
+    public function clear(): bool
+    {
+        return true;
+    }
+}
diff --git a/src/Framework/Cache/Driver/RedisCache.php b/src/Framework/Cache/Driver/RedisCache.php
new file mode 100644
index 00000000..3cf281ea
--- /dev/null
+++ b/src/Framework/Cache/Driver/RedisCache.php
@@ -0,0 +1,134 @@
+<?php
+
+namespace App\Framework\Cache\Driver;
+
+use App\Framework\Cache\CacheDriver;
+use App\Framework\Cache\CacheItem;
+use App\Framework\Cache\CachePrefix;
+use App\Framework\Cache\Serializer;
+use Predis\Client as Redis;
+
+final readonly class RedisCache implements CacheDriver
+{
+    private Redis $redis;
+
+    public function __construct(
+        string $host = '127.0.0.1',
+        int $port = 6379,
+        ?string $password = null,
+        int $db = 0,
+        #private Serializer $serializer = new Serializer\PhpSerializer(),
+        private string $prefix = 'cache:'
+    )
+    {
+        $this->redis = new Redis(
+            parameters: [
+                'scheme' => 'tcp',
+                'timeout' => 1.0,
+                'read_write_timeout' => 1.0,
+                'host' => $host,
+                'port' => $port,
+            ]
+        );
+
+        #$this->redis->connect();
+
+        if ($password) {
+            $this->redis->auth($password);
+        }
+        $this->redis->select($db);
+    }
+
+    private function prefixKey(string $key): string
+    {
+        return $this->prefix . $key;
+    }
+
+    public function get(string $key): CacheItem
+    {
+        $key = $this->prefixKey($key);
+
+        $data = $this->redis->get($key);
+        if ($data === null) {
+            return CacheItem::miss($key);
+        }
+        #$decoded = $this->serializer->unserialize($data); // oder json_decode($data, true)
+        $decoded = $data;
+        /*if (!is_array($decoded) || !array_key_exists('value', $decoded)) {
+            return CacheItem::miss($key);
+        }*/
+
+        // TODO: REMOVE TTL
+        $ttl = $this->redis->ttl($key);
+        $expiresAt = $ttl > 0 ? (time() + $ttl) : null;
+        return CacheItem::hit(
+            key  : $key,
+            value: $decoded,
+        );
+    }
+
+    public function set(string $key, string $value, ?int $ttl = null): bool
+    {
+        $key = $this->prefixKey($key);
+
+        #$payload = $this->serializer->serialize($value); #war: ['value' => $value]
+
+        $payload = $value;
+
+        if ($ttl !== null) {
+            return $this->redis->setex($key, $ttl, $payload)->getPayload() === 'OK';
+        }
+        return $this->redis->set($key, $payload)->getPayload() === 'OK';
+    }
+
+    public function has(string $key): bool
+    {
+        $key = $this->prefixKey($key);
+
+        return $this->redis->exists($key) > 0;
+    }
+
+    public function forget(string $key): bool
+    {
+        $key = $this->prefixKey($key);
+
+        return $this->redis->del($key) > 0;
+    }
+
+    public function clear(): bool
+    {
+        try {
+            $patterns = array_map(
+                fn($prefix) => $prefix->value . '*',
+                CachePrefix::cases()
+            );
+
+            foreach($patterns as $pattern) {
+                $this->clearByPattern($pattern);
+            }
+            return true;
+        }  catch (\Throwable $e) {
+            return false;
+        }
+    }
+
+    private function clearByPattern(string $pattern): void
+    {
+        $cursor = 0;
+        $batchSize = 1000; // Batch-Größe für bessere Performance
+
+        do {
+            $result = $this->redis->scan($cursor, [
+                'MATCH' => $pattern,
+                'COUNT' => $batchSize
+            ]);
+
+            $cursor = $result[0];
+            $keys = $result[1];
+
+            if (!empty($keys)) {
+                $this->redis->del($keys);
+            }
+        } while ($cursor !== 0);
+    }
+}
diff --git a/src/Framework/Cache/FileCacheCleaner.php b/src/Framework/Cache/FileCacheCleaner.php
new file mode 100644
index 00000000..af3a273e
--- /dev/null
+++ b/src/Framework/Cache/FileCacheCleaner.php
@@ -0,0 +1,38 @@
+<?php
+
+namespace App\Framework\Cache;
+
+use App\Framework\Filesystem\FileStorage;
+use App\Framework\Filesystem\Storage;
+
+final readonly class FileCacheCleaner
+{
+    public function __construct(
+        private Storage $fileSystem = new FileStorage(),
+        private string           $cacheFolder = __DIR__.'/storage/cache/'
+    ) {}
+
+    /**
+     * Löscht alle abgelaufenen Cache-Dateien im Cache-Verzeichnis.
+     * Rückgabe: Anzahl gelöschter Dateien
+     */
+    public function clean(): int
+    {
+        $now = time();
+        $deleted = 0;
+        // Alle passenden Cache-Files suchen (z.B. abcdef12345_1717000000.cache.php)
+        foreach ($this->fileSystem->listDirectory($this->cacheFolder, '*.cache.php') as $file) {
+            // Expires-At aus Dateiname extrahieren
+            if (preg_match('/_(\d+)\.cache\.php$/', $file, $match)) {
+                $expiresAt = (int)$match[1];
+                if ($expiresAt > 0 && $expiresAt < $now) {
+                    if ($this->fileSystem->delete($file) === null) {
+                        $deleted++;
+                    }
+                }
+            }
+        }
+        return $deleted;
+    }
+
+}
diff --git a/src/Framework/Cache/GeneralCache.php b/src/Framework/Cache/GeneralCache.php
new file mode 100644
index 00000000..a354c356
--- /dev/null
+++ b/src/Framework/Cache/GeneralCache.php
@@ -0,0 +1,48 @@
+<?php
+
+namespace App\Framework\Cache;
+
+final readonly class GeneralCache implements Cache
+{
+    public function __construct(
+        private CacheDriver $adapter
+    ) {}
+
+    public function get(string $key): CacheItem
+    {
+        return $this->adapter->get($key);
+    }
+
+    public function set(string $key, mixed $value, ?int $ttl = null): bool
+    {
+        return $this->adapter->set($key, $value, $ttl);
+    }
+
+    public function has(string $key): bool
+    {
+        return $this->adapter->has($key);
+    }
+
+    public function forget(string $key): bool
+    {
+        return $this->adapter->forget($key);
+    }
+
+    public function clear(): bool
+    {
+        return $this->adapter->clear();
+    }
+
+    public function remember(string $key, callable $callback, int $ttl = 3600): CacheItem
+    {
+        $item = $this->get($key);
+
+        if ($item->isHit) {
+            return $item;
+        }
+        $value = $callback();
+        $this->set($key, $value, $ttl);
+        return $this->get($key)->isHit ? $this->get($key) : CacheItem::hit($key, $value);
+
+    }
+}
diff --git a/src/Framework/Cache/LoggingCacheDecorator.php b/src/Framework/Cache/LoggingCacheDecorator.php
new file mode 100644
index 00000000..734fda26
--- /dev/null
+++ b/src/Framework/Cache/LoggingCacheDecorator.php
@@ -0,0 +1,103 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Cache;
+
+final readonly class LoggingCacheDecorator implements Cache
+{
+    public function __construct(
+        private Cache $innerCache,
+    ) {}
+
+    public function get(string $key): CacheItem
+    {
+        $cacheItem = $this->innerCache->get($key);
+        $status = $cacheItem->isHit ? 'HIT' : 'MISS';
+        $valueType = $cacheItem->value === null ? 'NULL' : gettype($cacheItem->value);
+        error_log("Cache {$status}: {$key} (value: {$valueType})");
+        return $cacheItem;
+    }
+
+    public function set(string $key, mixed $value, ?int $ttl = null): bool
+    {
+        $result = $this->innerCache->set($key, $value, $ttl);
+        $valueType = $value === null ? 'NULL' : gettype($value);
+        $ttlStr = $ttl === null ? 'default' : (string)$ttl;
+        $success = $result ? 'YES' : 'NO';
+        error_log("Cache SET: {$key} = {$valueType}, TTL: {$ttlStr}, Success: {$success}");
+        return $result;
+    }
+
+    public function has(string $key): bool
+    {
+        $exists = $this->innerCache->has($key);
+        $existsStr = $exists ? 'YES' : 'NO';
+        error_log("Cache HAS: {$key} = {$existsStr}");
+        return $exists;
+    }
+
+    public function forget(string $key): bool
+    {
+        $result = $this->innerCache->forget($key);
+        $success = $result ? 'YES' : 'NO';
+        error_log("Cache FORGET: {$key}, Success: {$success}");
+        return $result;
+    }
+
+    public function clear(): bool
+    {
+        $result = $this->innerCache->clear();
+        $success = $result ? 'YES' : 'NO';
+        error_log("Cache CLEAR: Success: {$success}");
+        return $result;
+    }
+
+    public function getMultiple(array $keys): array
+    {
+        $items = $this->innerCache->getMultiple($keys);
+        $hitCount = 0;
+        $missCount = 0;
+
+        foreach ($items as $item) {
+            if ($item->isHit) {
+                $hitCount++;
+            } else {
+                $missCount++;
+            }
+        }
+
+        $keyList = implode(', ', $keys);
+        error_log("Cache GET_MULTIPLE: [{$keyList}] - Hits: {$hitCount}, Misses: {$missCount}");
+        return $items;
+    }
+
+    public function setMultiple(array $items, ?int $ttl = null): bool
+    {
+        $result = $this->innerCache->setMultiple($items, $ttl);
+        $count = count($items);
+        $ttlStr = $ttl === null ? 'default' : (string)$ttl;
+        $success = $result ? 'YES' : 'NO';
+        error_log("Cache SET_MULTIPLE: {$count} items, TTL: {$ttlStr}, Success: {$success}");
+        return $result;
+    }
+
+    public function deleteMultiple(array $keys): bool
+    {
+        $result = $this->innerCache->deleteMultiple($keys);
+        $count = count($keys);
+        $success = $result ? 'YES' : 'NO';
+        error_log("Cache DELETE_MULTIPLE: {$count} keys, Success: {$success}");
+        return $result;
+    }
+
+
+    public function remember(string $key, callable $callback, int $ttl = 3600): CacheItem
+    {
+        $result = $this->innerCache->remember($key, $callback, $ttl);
+
+        $success = $result->isHit ? 'YES' : 'NO';
+        error_log("Cache REMEMBER: {$key}, Success: {$success}");
+        return $result;
+    }
+}
diff --git a/src/Framework/Cache/MultiLevelCache.php b/src/Framework/Cache/MultiLevelCache.php
new file mode 100644
index 00000000..fcfc2b1c
--- /dev/null
+++ b/src/Framework/Cache/MultiLevelCache.php
@@ -0,0 +1,124 @@
+<?php
+
+namespace App\Framework\Cache;
+
+final readonly class MultiLevelCache implements Cache
+{
+    private const int MAX_FAST_CACHE_SIZE = 1024; //1KB
+    private const int FAST_CACHE_TTL = 300;
+    public function __construct(
+        private Cache $fastCache,   // z.B. ArrayCache
+        private Cache $slowCache    // z.B. RedisCache, FileCache
+    ) {}
+
+    public function get(string $key): CacheItem
+    {
+        $item = $this->fastCache->get($key);
+        if ($item->isHit) {
+            return $item;
+        }
+
+        // Fallback auf "langsame" Ebene
+        $item = $this->slowCache->get($key);
+        if ($item->isHit) {
+            // In schnellen Cache zurücklegen (optional mit TTL aus Slow-Item)
+            if($this->shouldCacheInFast($item->value)) {
+                $this->fastCache->set($key, $item->value, self::FAST_CACHE_TTL);
+            }
+        }
+        return $item;
+    }
+
+    public function set(string $key, mixed $value, ?int $ttl = null): bool
+    {
+        $slowSuccess = $this->slowCache->set($key, $value, $ttl);
+
+        $fastSuccess = true;
+        if($this->shouldCacheInFast($value)) {
+            $fastTtl = min($ttl ?? self::FAST_CACHE_TTL, self::FAST_CACHE_TTL);
+            $fastSuccess = $this->fastCache->set($key, $value, $fastTtl);
+        }
+
+        return $slowSuccess && $fastSuccess;
+    }
+
+    public function forget(string $key): bool
+    {
+        $s1 = $this->fastCache->forget($key);
+        $s2 = $this->slowCache->forget($key);
+        return $s1 && $s2;
+    }
+
+    public function clear(): bool
+    {
+        $s1 = $this->fastCache->clear();
+        $s2 = $this->slowCache->clear();
+        return $s1 && $s2;
+    }
+
+    /*
+     * - **has**: Versucht zuerst den schnelleren Layer. Im Falle eines Hits im "slowCache" wird der Wert aufgewärmt/gecached, damit zukünftige Zugriffe wieder schneller sind.
+
+     */
+    public function has(string $key): bool
+    {
+        // Schneller Check im Fast-Cache
+        if ($this->fastCache->has($key)) {
+            return true;
+        }
+        // Ggf. im Slow-Cache prüfen (und dann in Fast-Cache "aufwärmen")
+        $slowHit = $this->slowCache->get($key);
+        if ($slowHit->isHit) {
+            if($this->shouldCacheInFast($slowHit->value)) {
+                $this->fastCache->set($key, $slowHit->value, self::FAST_CACHE_TTL);
+            }
+
+            return true;
+        }
+        return false;
+
+    }
+
+    /*
+     * - **remember**: Holt sich das Item per `get` (inkl. aller Multi-Level-Vorteile, wie bereits vorhanden). Wenn nicht im Cache, wird das Callback ausgeführt, gespeichert und als Treffer zurückgegeben.
+     */
+
+    public function remember(string $key, callable $callback, int $ttl = 3600): CacheItem
+    {
+        $item = $this->get($key);
+        if ($item->isHit) {
+            return $item;
+        }
+
+        // Wert generieren, speichern und zurückgeben
+        $value = $callback();
+        $this->set($key, $value, $ttl);
+        // Erstelle neuen CacheItem als Treffer
+        return CacheItem::hit($key, $value);
+
+    }
+
+    private function shouldCacheInFast(mixed $value): bool
+    {
+        // Wenn es bereits ein String ist (serialisiert), nutze dessen Länge
+        if (is_string($value)) {
+            return strlen($value) <= self::MAX_FAST_CACHE_SIZE;
+        }
+
+        // Für Arrays: Schnelle Heuristik ohne Serialisierung
+        if (is_array($value)) {
+            $elementCount = count($value, COUNT_RECURSIVE);
+            // Grobe Schätzung: 50 Bytes pro Element
+            $estimatedSize = $elementCount * 50;
+            return $estimatedSize <= self::MAX_FAST_CACHE_SIZE;
+        }
+
+        // Für Objekte: Konservativ - nicht in fast cache
+        if (is_object($value)) {
+            return false;
+        }
+
+        // Primitive Typen: Immer cachen
+        return true;
+    }
+}
diff --git a/src/Framework/Cache/Serializer.php b/src/Framework/Cache/Serializer.php
new file mode 100644
index 00000000..d31df356
--- /dev/null
+++ b/src/Framework/Cache/Serializer.php
@@ -0,0 +1,9 @@
+<?php
+
+namespace App\Framework\Cache;
+
+interface Serializer
+{
+    public function serialize(mixed $value): string;
+    public function unserialize(string $value): mixed;
+}
diff --git a/src/Framework/Cache/Serializer/JsonSerializer.php b/src/Framework/Cache/Serializer/JsonSerializer.php
new file mode 100644
index 00000000..2c28a50e
--- /dev/null
+++ b/src/Framework/Cache/Serializer/JsonSerializer.php
@@ -0,0 +1,25 @@
+<?php
+
+namespace App\Framework\Cache\Serializer;
+
+use App\Framework\Cache\Serializer;
+use JsonException;
+
+final readonly class JsonSerializer implements Serializer
+{
+    /**
+     * @throws JsonException
+     */
+    public function serialize(mixed $value): string
+    {
+        return json_encode($value, JSON_THROW_ON_ERROR);
+    }
+
+    /**
+     * @throws JsonException
+     */
+    public function unserialize(string $value): mixed
+    {
+        return json_decode($value, true, 512, JSON_THROW_ON_ERROR);
+    }
+}
diff --git a/src/Framework/Cache/Serializer/PhpSerializer.php b/src/Framework/Cache/Serializer/PhpSerializer.php
new file mode 100644
index 00000000..ebb8d729
--- /dev/null
+++ b/src/Framework/Cache/Serializer/PhpSerializer.php
@@ -0,0 +1,19 @@
+<?php
+
+namespace App\Framework\Cache\Serializer;
+
+use App\Framework\Cache\Serializer;
+
+final readonly class PhpSerializer implements Serializer
+{
+
+    public function serialize(mixed $value): string
+    {
+        return serialize($value);
+    }
+
+    public function unserialize(string $value): mixed
+    {
+        return unserialize($value);
+    }
+}
diff --git a/src/Framework/Cache/TaggedCache.php b/src/Framework/Cache/TaggedCache.php
new file mode 100644
index 00000000..e10eb9ad
--- /dev/null
+++ b/src/Framework/Cache/TaggedCache.php
@@ -0,0 +1,11 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Cache;
+
+final readonly class TaggedCache
+{
+    public function __construct(
+        public Cache $cache
+    ) {}
+}
diff --git a/src/Framework/CommandBus/CommandBus.php b/src/Framework/CommandBus/CommandBus.php
new file mode 100644
index 00000000..99e18377
--- /dev/null
+++ b/src/Framework/CommandBus/CommandBus.php
@@ -0,0 +1,8 @@
+<?php
+
+namespace App\Framework\CommandBus;
+
+interface CommandBus
+{
+    public function dispatch(object $command): mixed;
+}
diff --git a/src/Framework/CommandBus/CommandBusInitializer.php b/src/Framework/CommandBus/CommandBusInitializer.php
new file mode 100644
index 00000000..e79ae1e9
--- /dev/null
+++ b/src/Framework/CommandBus/CommandBusInitializer.php
@@ -0,0 +1,32 @@
+<?php
+
+namespace App\Framework\CommandBus;
+
+use App\Framework\Context\ExecutionContext;
+use App\Framework\DI\DefaultContainer;
+use App\Framework\DI\Initializer;
+use App\Framework\Discovery\Results\DiscoveryResults;
+
+final readonly class CommandBusInitializer
+{
+    public function __construct(
+        private DefaultContainer $container,
+        private DiscoveryResults $results,
+        private ExecutionContext $executionContext,
+    ) {}
+
+    #[Initializer]
+    public function __invoke(): CommandBus
+    {
+        $this->results->get(CommandHandler::class);
+
+        $handlers = [];
+        foreach($this->results->get(CommandHandler::class) as $handler) {
+
+            $handlers[] = CommandHandlerDescriptor::fromHandlerArray($handler);
+        }
+        $handlersCollection = new CommandHandlersCollection(...$handlers);
+
+        return new DefaultCommandBus($handlersCollection, $this->container, $this->executionContext);
+    }
+}
diff --git a/src/Framework/CommandBus/CommandHandler.php b/src/Framework/CommandBus/CommandHandler.php
new file mode 100644
index 00000000..b1983904
--- /dev/null
+++ b/src/Framework/CommandBus/CommandHandler.php
@@ -0,0 +1,12 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\CommandBus;
+
+use Attribute;
+
+#[Attribute(\Attribute::TARGET_METHOD)]
+final class CommandHandler
+{
+
+}
diff --git a/src/Framework/CommandBus/CommandHandlerCompiler.php b/src/Framework/CommandBus/CommandHandlerCompiler.php
new file mode 100644
index 00000000..b01e3f5a
--- /dev/null
+++ b/src/Framework/CommandBus/CommandHandlerCompiler.php
@@ -0,0 +1,43 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\CommandBus;
+
+use App\Framework\Core\AttributeCompiler;
+
+final readonly class CommandHandlerCompiler implements AttributeCompiler
+{
+    public function getAttributeClass(): string
+    {
+        return CommandHandler::class;
+    }
+
+    public function compile(array $handlers): array
+    {
+        $compiledHandlers = [];
+
+        foreach ($handlers as $handler) {
+            $className = $handler['class'];
+            $methodName = $handler['method'];
+
+            // Ermittle den Command-Typ aus dem ersten Parameter der Methode
+            $methodInfo = new \ReflectionMethod($className, $methodName);
+            $parameters = $methodInfo->getParameters();
+
+            if (count($parameters) > 0) {
+                $paramType = $parameters[0]->getType();
+                if ($paramType instanceof \ReflectionNamedType) {
+                    $commandClass = $paramType->getName();
+
+                    // Speichere den Handler für diesen Command-Typ
+                    $compiledHandlers[$commandClass] = [
+                        'class' => $className,
+                        'method' => $methodName,
+                    ];
+                }
+            }
+        }
+
+        return $compiledHandlers;
+    }
+}
diff --git a/src/Framework/CommandBus/CommandHandlerDescriptor.php b/src/Framework/CommandBus/CommandHandlerDescriptor.php
new file mode 100644
index 00000000..57e5b06c
--- /dev/null
+++ b/src/Framework/CommandBus/CommandHandlerDescriptor.php
@@ -0,0 +1,25 @@
+<?php
+
+namespace App\Framework\CommandBus;
+
+/**
+ * Kapselt Handler-Information für einen Command
+ */
+
+final readonly class CommandHandlerDescriptor
+{
+    public function __construct(
+        public string $class,
+        public string $method,
+        public string $command,
+    ) {}
+
+    public static function fromHandlerArray(array $handler): self
+    {
+        return new self(
+            class: $handler['class'],
+            method: $handler['method'],
+            command: $handler['command'],
+        );
+    }
+}
diff --git a/src/Framework/CommandBus/CommandHandlerMapper.php b/src/Framework/CommandBus/CommandHandlerMapper.php
new file mode 100644
index 00000000..97ef937d
--- /dev/null
+++ b/src/Framework/CommandBus/CommandHandlerMapper.php
@@ -0,0 +1,33 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\CommandBus;
+
+use App\Framework\Core\AttributeMapper;
+use ReflectionMethod;
+use RuntimeException;
+
+final class CommandHandlerMapper implements AttributeMapper
+{
+    public function getAttributeClass(): string
+    {
+        return CommandHandler::class;
+    }
+
+    public function map(object $reflectionTarget, object $attributeInstance): ?array
+    {
+        if (!$reflectionTarget instanceof ReflectionMethod || !$attributeInstance instanceof CommandHandler) {
+            return null;
+        }
+
+        if(empty($reflectionTarget->getParameters()[0])) {
+            throw new RuntimeException('Missing Command-Type');
+        }
+
+        return [
+            'class' => $reflectionTarget->getDeclaringClass()->getName(),
+            'method' => $reflectionTarget->getName(),
+            'command' => $reflectionTarget->getParameters()[0]->getType()->getName(),
+        ];
+    }
+}
diff --git a/src/Framework/CommandBus/CommandHandlersCollection.php b/src/Framework/CommandBus/CommandHandlersCollection.php
new file mode 100644
index 00000000..c34728ca
--- /dev/null
+++ b/src/Framework/CommandBus/CommandHandlersCollection.php
@@ -0,0 +1,58 @@
+<?php
+
+namespace App\Framework\CommandBus;
+
+use ArrayIterator;
+use Countable;
+use IteratorAggregate;
+use Traversable;
+
+final readonly class CommandHandlersCollection implements IteratorAggregate, Countable
+{
+    private array $handlers;
+    public function __construct(
+        CommandHandlerDescriptor ...$handlers
+        #private array $handlers = []
+    ){
+        $handlerArray = [];
+        foreach ($handlers as $handler) {
+
+            $handlerArray[$handler->command] = $handler;
+        }
+        $this->handlers = $handlerArray;
+    }
+
+    /*private function add(string $messageClass, object $handler): void
+    {
+        $this->handlers[$messageClass] = $handler;
+    }*/
+
+    /**
+     * @param class-string $commandClass
+     * @return CommandHandlerDescriptor|null
+     */
+    public function get(string $commandClass): ?CommandHandlerDescriptor
+    {
+        return $this->handlers[$commandClass] ?? null;
+    }
+
+    public function all(): array
+    {
+        return $this->toArray();
+    }
+
+    public function getIterator(): Traversable
+    {
+        return new ArrayIterator($this->handlers);
+    }
+
+    public function count(): int
+    {
+        return count($this->handlers);
+    }
+
+    public function toArray(): array
+    {
+        return $this->handlers;
+    }
+}
diff --git a/src/Framework/CommandBus/DefaultCommandBus.php b/src/Framework/CommandBus/DefaultCommandBus.php
new file mode 100644
index 00000000..cb2cf217
--- /dev/null
+++ b/src/Framework/CommandBus/DefaultCommandBus.php
@@ -0,0 +1,103 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\CommandBus;
+
+use App\Application\Auth\LoginUser;
+use App\Framework\CommandBus\Exceptions\NoHandlerFound;
+use App\Framework\CommandBus\Middleware\DatabaseTransactionMiddleware;
+use App\Framework\CommandBus\Middleware\PerformanceMonitoringMiddleware;
+use App\Framework\Context\ExecutionContext;
+use App\Framework\Context\ContextType;
+use App\Framework\DI\Container;
+use App\Framework\DI\DefaultContainer;
+use App\Framework\Queue\FileQueue;
+use App\Framework\Queue\Queue;
+use App\Framework\Queue\RedisQueue;
+
+final readonly class DefaultCommandBus implements CommandBus
+{
+    public function __construct(
+        private CommandHandlersCollection $commandHandlers,
+        private Container                 $container,
+        private ExecutionContext          $executionContext,
+        private Queue                     $queue = new RedisQueue(host: 'redis'),
+        private array                     $middlewares = [
+            PerformanceMonitoringMiddleware::class,
+            DatabaseTransactionMiddleware::class,
+        ],
+    ) {}
+
+    public function dispatch(object $command): mixed
+    {
+        $contextType = $this->executionContext->getType();
+        error_log("CommandBus Debug: Execution context: {$contextType->value}");
+        error_log("CommandBus Debug: Context metadata: " . json_encode($this->executionContext->getMetadata()));
+
+        // Context-basierte Queue-Entscheidung
+        if ($this->shouldQueueInContext($command, $contextType)) {
+            error_log("CommandBus Debug: Job wird in Queue eingereiht: " . $command::class);
+            $this->queue->push($command);
+            return null;
+        }
+
+        error_log("CommandBus Debug: Job wird direkt ausgeführt: " . $command::class);
+        return $this->executeCommand($command);
+    }
+
+    private function executeCommand(object $command): mixed
+    {
+        $handlerExecutor = function (object $command): mixed {
+            $handler = $this->commandHandlers->get($command::class);
+
+            if($handler === null)
+            {
+               throw NoHandlerFound::forCommand($command::class);
+            }
+
+            // $handler = $this->commandHandlers[get_class($command)];
+            $handlerClass = $this->container->get($handler->class);
+            return $handlerClass->{$handler->method}($command);
+        };
+
+        $pipeline = array_reduce(
+            array_reverse($this->middlewares),
+            function (callable $next, string $middlewareClass): callable {
+                return function (object $command) use ($middlewareClass, $next): mixed {
+                    /** @var Middleware $middleware */
+                    $middleware = $this->container->get($middlewareClass);
+                    return $middleware->handle($command, $next);
+                };
+            },
+            $handlerExecutor
+        );
+
+        return $pipeline($command);
+    }
+
+    private function shouldQueueInContext(object $command, ContextType $context): bool
+    {
+        $ref = new \ReflectionClass($command);
+        $hasQueueAttribute = !empty($ref->getAttributes(ShouldQueue::class));
+
+        if (!$hasQueueAttribute) {
+            return false; // Ohne #[ShouldQueue] Attribut nie queuen
+        }
+
+        // Context-basierte Entscheidung
+        return match($context) {
+            ContextType::WORKER => false,      // Worker: NIEMALS queuen
+            ContextType::CONSOLE => false,     // Artisan: meist direkt
+            ContextType::TEST => false,        // Tests: immer direkt
+            ContextType::CLI_SCRIPT => true,   // CLI Scripts: normal queuen
+            ContextType::WEB => true,          // Web: Standard Queue-Verhalten
+        };
+    }
+
+
+
+    public function __debugInfo(): ?array
+    {
+        return $this->commandHandlers->toArray();
+    }
+}
diff --git a/src/Framework/CommandBus/Exceptions/NoHandlerFound.php b/src/Framework/CommandBus/Exceptions/NoHandlerFound.php
new file mode 100644
index 00000000..3d66cdd8
--- /dev/null
+++ b/src/Framework/CommandBus/Exceptions/NoHandlerFound.php
@@ -0,0 +1,16 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\CommandBus\Exceptions;
+
+use App\Framework\Exception\FrameworkException;
+
+final class NoHandlerFound extends FrameworkException
+{
+    public static function forCommand(string $commandClass): self
+    {
+        return new self(
+            "No handler found for command: $commandClass"
+        );
+    }
+}
diff --git a/src/Framework/CommandBus/Middleware.php b/src/Framework/CommandBus/Middleware.php
new file mode 100644
index 00000000..1c754a3a
--- /dev/null
+++ b/src/Framework/CommandBus/Middleware.php
@@ -0,0 +1,8 @@
+<?php
+
+namespace App\Framework\CommandBus;
+
+interface Middleware
+{
+    public function handle(object $command, callable $next): mixed;
+}
diff --git a/src/Framework/CommandBus/Middleware/DatabaseTransactionMiddleware.php b/src/Framework/CommandBus/Middleware/DatabaseTransactionMiddleware.php
new file mode 100644
index 00000000..92ecfdfe
--- /dev/null
+++ b/src/Framework/CommandBus/Middleware/DatabaseTransactionMiddleware.php
@@ -0,0 +1,19 @@
+<?php
+
+namespace App\Framework\CommandBus\Middleware;
+
+use App\Framework\CommandBus\Middleware;
+
+final readonly class DatabaseTransactionMiddleware implements Middleware
+{
+    public function __construct() {}
+
+    public function handle(object $command, callable $next): mixed
+    {
+        #var_dump('DatabaseTransactionMiddleware');
+
+        // Wenn die Validierung erfolgreich ist, wird der nächste Schritt aufgerufen
+        return $next($command);
+    }
+
+}
diff --git a/src/Framework/CommandBus/Middleware/LoggingMiddleware.php b/src/Framework/CommandBus/Middleware/LoggingMiddleware.php
new file mode 100644
index 00000000..2b2cf3c2
--- /dev/null
+++ b/src/Framework/CommandBus/Middleware/LoggingMiddleware.php
@@ -0,0 +1,26 @@
+<?php
+
+namespace App\Framework\CommandBus\Middleware;
+
+use App\Framework\CommandBus\Middleware;
+use App\Framework\Logging\DefaultLogger;
+use App\Framework\Logging\Logger;
+
+final readonly class LoggingMiddleware implements Middleware
+{
+    public function __construct(
+        private Logger $logger
+    ) {}
+
+    public function handle(object $command, callable $next): mixed
+    {
+        $commandClass = get_class($command);
+        $this->logger->info("Starting command: $commandClass");
+
+        $result = $next($command);
+
+        $this->logger->info("Finished command: $commandClass");
+
+        return $result;
+    }
+}
diff --git a/src/Framework/CommandBus/Middleware/PerformanceMonitoringMiddleware.php b/src/Framework/CommandBus/Middleware/PerformanceMonitoringMiddleware.php
new file mode 100644
index 00000000..f2071091
--- /dev/null
+++ b/src/Framework/CommandBus/Middleware/PerformanceMonitoringMiddleware.php
@@ -0,0 +1,25 @@
+<?php
+
+namespace App\Framework\CommandBus\Middleware;
+
+use App\Framework\CommandBus\Middleware;
+use App\Framework\Performance\PerformanceCategory;
+use App\Framework\Performance\PerformanceMeter;
+
+final readonly class PerformanceMonitoringMiddleware implements Middleware
+{
+    public function __construct(
+        private PerformanceMeter $meter
+    ) {}
+
+    public function handle(object $command, callable $next): mixed
+    {
+        $this->meter->startMeasure($command::class, PerformanceCategory::SYSTEM);
+
+        $result = $next($command);
+
+        $this->meter->endMeasure($command::class);
+
+        return $result;
+    }
+}
diff --git a/src/Framework/CommandBus/ShouldQueue.php b/src/Framework/CommandBus/ShouldQueue.php
new file mode 100644
index 00000000..41043f9b
--- /dev/null
+++ b/src/Framework/CommandBus/ShouldQueue.php
@@ -0,0 +1,9 @@
+<?php
+
+namespace App\Framework\CommandBus;
+
+#[\Attribute(\Attribute::TARGET_CLASS)]
+class ShouldQueue
+{
+    // Hier könnten noch Optionen rein (z. B. Queue-Name, Delay …)
+}
diff --git a/src/Framework/Config/AppConfig.php b/src/Framework/Config/AppConfig.php
new file mode 100644
index 00000000..6f8e9058
--- /dev/null
+++ b/src/Framework/Config/AppConfig.php
@@ -0,0 +1,18 @@
+<?php
+
+namespace App\Framework\Config;
+
+use App\Framework\DateTime\Timezone;
+
+final readonly class AppConfig
+{
+    public function __construct(
+        public string $name = 'Framework App',
+        public string $version = '1.0.0',
+        public string $environment = 'production',
+        public bool $debug = false,
+        public Timezone $timezone = Timezone::DEFAULT,
+        public string $locale = 'en',
+        public EnvironmentType $type = EnvironmentType::DEV
+    ) {}
+}
diff --git a/src/Framework/Config/Configuration.php b/src/Framework/Config/Configuration.php
new file mode 100644
index 00000000..34410d94
--- /dev/null
+++ b/src/Framework/Config/Configuration.php
@@ -0,0 +1,117 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Config;
+
+class Configuration
+{
+    private array $config = [];
+
+    /**
+     * Lädt Konfigurationen aus einer oder mehreren Quellen
+     */
+    public function __construct(array $config = [])
+    {
+        $this->config = $config;
+    }
+
+    /**
+     * Lädt Konfigurationen aus PHP-Dateien
+     */
+    public function loadFromFile(string $path): self
+    {
+        if (file_exists($path) && is_readable($path)) {
+            $fileConfig = require $path;
+            if (is_array($fileConfig)) {
+                $this->config = array_merge($this->config, $fileConfig);
+            }
+        }
+
+        return $this;
+    }
+
+    /**
+     * Lädt Konfigurationen aus einem Verzeichnis
+     */
+    public function loadFromDirectory(string $directory): self
+    {
+        if (!is_dir($directory)) {
+            return $this;
+        }
+
+        foreach (glob($directory . '/*.php') as $file) {
+            $this->loadFromFile($file);
+        }
+
+        return $this;
+    }
+
+    /**
+     * Gibt einen Konfigurationswert zurück
+     */
+    public function get(string $key, mixed $default = null): mixed
+    {
+        $keys = explode('.', $key);
+        $value = $this->config;
+
+        foreach ($keys as $segment) {
+            if (!is_array($value) || !array_key_exists($segment, $value)) {
+                return $default;
+            }
+            $value = $value[$segment];
+        }
+
+        return $value;
+    }
+
+    /**
+     * Setzt einen Konfigurationswert
+     */
+    public function set(string $key, mixed $value): self
+    {
+        $keys = explode('.', $key);
+        $config = &$this->config;
+
+        foreach ($keys as $i => $segment) {
+            if ($i === count($keys) - 1) {
+                $config[$segment] = $value;
+                break;
+            }
+
+            if (!isset($config[$segment]) || !is_array($config[$segment])) {
+                $config[$segment] = [];
+            }
+
+            $config = &$config[$segment];
+        }
+
+        return $this;
+    }
+
+    /**
+     * Prüft, ob ein Konfigurationswert existiert
+     */
+    public function has(string $key): bool
+    {
+        $keys = explode('.', $key);
+        $config = $this->config;
+
+        foreach ($keys as $segment) {
+            if (!is_array($config) || !array_key_exists($segment, $config)) {
+                return false;
+            }
+            $config = $config[$segment];
+        }
+
+        return true;
+    }
+
+    /**
+     * Gibt alle Konfigurationswerte zurück
+     */
+    public function all(): array
+    {
+        return $this->config;
+    }
+}
diff --git a/src/Framework/Config/EnvKey.php b/src/Framework/Config/EnvKey.php
new file mode 100644
index 00000000..2f631444
--- /dev/null
+++ b/src/Framework/Config/EnvKey.php
@@ -0,0 +1,11 @@
+<?php
+
+namespace App\Framework\Config;
+
+enum EnvKey: string
+{
+    case APP_DEBUG = 'APP_DEBUG';
+    case APP_ENV = 'APP_ENV';
+    case APP_TIMEZONE = 'APP_TIMEZONE';
+    case APP_LOCALE = 'APP_LOCALE';
+}
diff --git a/src/Framework/Config/Environment.php b/src/Framework/Config/Environment.php
new file mode 100644
index 00000000..4a8e3fc1
--- /dev/null
+++ b/src/Framework/Config/Environment.php
@@ -0,0 +1,143 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Config;
+
+use App\Framework\Config\Exceptions\RequiredEnvironmentVariableException;
+
+final readonly class Environment
+{
+    public function __construct(
+        private array $variables = []
+    ){}
+
+    public function get(EnvKey|string $key, mixed $default = null): mixed
+    {
+        $key = $this->keyToString($key);
+        // Priorität: 1. System ENV, 2. Loaded variables, 3. Default
+        return $_ENV[$key] ?? $_SERVER[$key] ?? getenv($key) ?: $this->variables[$key] ?? $default;
+    }
+
+    public function getRequired(EnvKey|string $key): mixed
+    {
+        $key = $this->keyToString($key);
+        $value = $this->get($key);
+        if ($value === null) {
+            throw new RequiredEnvironmentVariableException($key);
+        }
+        return $value;
+    }
+
+    public function getInt(EnvKey|string $key, int $default = 0): int
+    {
+        $key = $this->keyToString($key);
+        return (int) $this->get($key, $default);
+    }
+
+    public function getBool(EnvKey|string $key, bool $default = false): bool
+    {
+        $key = $this->keyToString($key);
+        $value = $this->get($key, $default);
+        if (is_string($value)) {
+            return match (strtolower($value)) {
+                'true', '1', 'yes', 'on' => true,
+                'false', '0', 'no', 'off' => false,
+                default => $default
+            };
+        }
+        return (bool) $value;
+    }
+
+    public function getString(EnvKey|string $key, string $default = ''): string
+    {
+        $key = $this->keyToString($key);
+        return (string) $this->get($key, $default);
+    }
+
+    public function getEnum(EnvKey|string $key, string $enumClass, \BackedEnum $default):object
+    {
+        $key = $this->keyToString($key);
+        return forward_static_call([$enumClass, 'tryFrom'], $this->get($key, $default));
+        #$enumClass::tryFrom($this->get($key, $default));
+    }
+
+    public function has(EnvKey|string $key): bool
+    {
+        $key = $this->keyToString($key);
+        return $this->get($key) !== null;
+    }
+
+    public function all(): array
+    {
+        return array_merge(
+            $_ENV,
+            $_SERVER,
+            $this->variables
+        );
+    }
+
+    /**
+     * Factory method für .env file loading
+     */
+    public static function fromFile(string $envPath): self
+    {
+        $variables = [];
+
+        if (file_exists($envPath) && is_readable($envPath)) {
+            $lines = file($envPath, FILE_IGNORE_NEW_LINES | FILE_SKIP_EMPTY_LINES);
+
+            foreach ($lines as $line) {
+                if (str_starts_with(trim($line), '#') || !str_contains($line, '=')) {
+                    continue;
+                }
+
+                [$name, $value] = explode('=', $line, 2);
+                $name = trim($name);
+                $value = trim($value);
+
+                // Remove quotes
+                if (str_starts_with($value, '"') && str_ends_with($value, '"')) {
+                    $value = substr($value, 1, -1);
+                }
+
+                $variables[$name] = self::castValue($value);
+            }
+        }
+
+        return new self($variables);
+    }
+
+    private static function castValue(string $value): mixed
+    {
+        return match (strtolower($value)) {
+            'true' => true,
+            'false' => false,
+            'null' => null,
+            default => is_numeric($value) ? (str_contains($value, '.') ? (float) $value : (int) $value) : $value
+        };
+    }
+
+    public function keyToString(EnvKey|string $key):string
+    {
+        if(is_string($key)) {
+            return $key;
+        }
+        return $key->value;
+    }
+
+    /**
+     * Für Tests
+     */
+    public function withVariable(string $key, mixed $value): self
+    {
+        $variables = $this->variables;
+        $variables[$key] = $value;
+        return new self($variables);
+    }
+
+    public function withVariables(array $variables): self
+    {
+        return new self(array_merge($this->variables, $variables));
+    }
+}
diff --git a/src/Framework/Config/EnvironmentType.php b/src/Framework/Config/EnvironmentType.php
new file mode 100644
index 00000000..923c0cec
--- /dev/null
+++ b/src/Framework/Config/EnvironmentType.php
@@ -0,0 +1,9 @@
+<?php
+
+namespace App\Framework\Config;
+
+enum EnvironmentType: string
+{
+    case DEV = 'development';
+    case PROD = 'production';
+}
diff --git a/src/Framework/Config/Exceptions/RequiredEnvironmentVariableException.php b/src/Framework/Config/Exceptions/RequiredEnvironmentVariableException.php
new file mode 100644
index 00000000..0613dbae
--- /dev/null
+++ b/src/Framework/Config/Exceptions/RequiredEnvironmentVariableException.php
@@ -0,0 +1,17 @@
+<?php
+
+namespace App\Framework\Config\Exceptions;
+
+use App\Framework\Exception\FrameworkException;
+
+class RequiredEnvironmentVariableException extends FrameworkException
+{
+
+    /**
+     * @param string $key
+     */
+    public function __construct(string $key)
+    {
+        parent::__construct("Required environment variable '$key' is not set.");
+    }
+}
diff --git a/src/Framework/Config/TypedConfigInitializer.php b/src/Framework/Config/TypedConfigInitializer.php
new file mode 100644
index 00000000..ada8a7d9
--- /dev/null
+++ b/src/Framework/Config/TypedConfigInitializer.php
@@ -0,0 +1,47 @@
+<?php
+
+namespace App\Framework\Config;
+
+use App\Framework\Context\ContextType;
+use App\Framework\DateTime\Timezone;
+use App\Framework\DI\Container;
+
+final readonly class TypedConfigInitializer
+{
+    public function __construct(
+        private Environment $env,
+    ){
+        #debug($env->getEnum('APP_ENV', EnvironmentType::class, EnvironmentType::PROD));
+    }
+
+    public function __invoke(Container $container): TypedConfiguration
+    {
+        $appConfig = $this->createAppConfig();
+
+        $container->instance(AppConfig::class, $appConfig);
+
+        return new TypedConfiguration(
+            app: $appConfig,
+        );
+    }
+
+    private function createAppConfig(): AppConfig
+    {
+        return new AppConfig(
+            environment: $this->env->getString(
+                key: EnvKey::APP_ENV,
+                default: 'production'
+            ),
+
+            debug: $this->env->getBool(EnvKey::APP_DEBUG),
+
+            timezone: $this->env->getEnum(
+                key: EnvKey::APP_TIMEZONE,
+                enumClass: Timezone::class,
+                default: Timezone::EuropeBerlin
+            ),
+
+            locale: $this->env->getString(EnvKey::APP_LOCALE, 'de'),
+        );
+    }
+}
diff --git a/src/Framework/Config/TypedConfiguration.php b/src/Framework/Config/TypedConfiguration.php
new file mode 100644
index 00000000..8e4a15b2
--- /dev/null
+++ b/src/Framework/Config/TypedConfiguration.php
@@ -0,0 +1,15 @@
+<?php
+
+namespace App\Framework\Config;
+
+use App\Framework\Database\Config\DatabaseConfig;
+
+final readonly class TypedConfiguration
+{
+    public function __construct(
+        #public DatabaseConfig $database,
+        public AppConfig $app,
+    )
+    {
+    }
+}
diff --git a/src/Framework/Console/Components/InteractiveMenu.php b/src/Framework/Console/Components/InteractiveMenu.php
new file mode 100644
index 00000000..4c8460a8
--- /dev/null
+++ b/src/Framework/Console/Components/InteractiveMenu.php
@@ -0,0 +1,257 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Console\Components;
+
+use App\Framework\Console\ConsoleColor;
+use App\Framework\Console\ConsoleOutput;
+
+/**
+ * Klasse für interaktive Menüs in der Konsole.
+ * Unterstützt sowohl einfache nummerierte Menüs als auch
+ * Menüs mit Pfeiltasten-Navigation.
+ */
+final class InteractiveMenu
+{
+    private ConsoleOutput $output;
+    private array $menuItems = [];
+    private string $title = '';
+    private int $selectedIndex = 0;
+    private bool $showNumbers = true;
+
+    public function __construct(ConsoleOutput $output)
+    {
+        $this->output = $output;
+    }
+
+    /**
+     * Setzt den Titel des Menüs.
+     */
+    public function setTitle(string $title): self
+    {
+        $this->title = $title;
+        return $this;
+    }
+
+    /**
+     * Fügt einen Menüpunkt hinzu.
+     *
+     * @param string $label Die Beschriftung des Menüpunkts
+     * @param callable|null $action Eine optionale Aktion, die bei Auswahl ausgeführt wird
+     * @param mixed $value Ein optionaler Wert, der zurückgegeben wird
+     */
+    public function addItem(string $label, ?callable $action = null, mixed $value = null): self
+    {
+        $this->menuItems[] = [
+            'label' => $label,
+            'action' => $action,
+            'value' => $value ?? $label
+        ];
+        return $this;
+    }
+
+    /**
+     * Fügt einen Separator zum Menü hinzu.
+     */
+    public function addSeparator(): self
+    {
+        $this->menuItems[] = [
+            'label' => '---',
+            'action' => null,
+            'value' => null,
+            'separator' => true
+        ];
+        return $this;
+    }
+
+    /**
+     * Steuert, ob Nummern angezeigt werden sollen.
+     */
+    public function showNumbers(bool $show = true): self
+    {
+        $this->showNumbers = $show;
+        return $this;
+    }
+
+    /**
+     * Zeigt ein einfaches Menü mit Nummern-Auswahl.
+     */
+    public function showSimple(): mixed
+    {
+        // Verwende den ScreenManager anstelle des direkten clearScreen()
+        $this->output->screen()->newMenu();
+
+        if ($this->title) {
+            $this->output->writeLine($this->title, ConsoleColor::BRIGHT_CYAN);
+            $this->output->writeLine(str_repeat('=', strlen($this->title)));
+            $this->output->writeLine('');
+        }
+
+        foreach ($this->menuItems as $index => $item) {
+            if (isset($item['separator'])) {
+                $this->output->writeLine($item['label'], ConsoleColor::GRAY);
+                continue;
+            }
+
+            $number = $this->showNumbers ? ($index + 1) . '. ' : '';
+            $this->output->writeLine($number . $item['label']);
+        }
+
+        $this->output->writeLine('');
+        $this->output->write('Ihre Wahl: ', ConsoleColor::BRIGHT_CYAN);
+
+        $input = trim(fgets(STDIN));
+
+        if (is_numeric($input)) {
+            $selectedIndex = (int)$input - 1;
+            if (isset($this->menuItems[$selectedIndex]) && !isset($this->menuItems[$selectedIndex]['separator'])) {
+                $item = $this->menuItems[$selectedIndex];
+
+                if ($item['action']) {
+                    return $item['action']();
+                }
+
+                return $item['value'];
+            }
+        }
+
+        $this->output->writeError('Ungültige Auswahl!');
+        return $this->showSimple();
+    }
+
+    /**
+     * Zeigt ein interaktives Menü mit Pfeiltasten-Navigation.
+     */
+    public function showInteractive(): mixed
+    {
+        $this->output->screen()->setInteractiveMode();
+
+        // Terminal in Raw-Modus setzen für Tastatur-Input
+        $this->setRawMode(true);
+
+        try {
+            while (true) {
+                $this->renderMenu();
+                $key = $this->readKey();
+
+                switch ($key) {
+                    case "\033[A": // Pfeil hoch
+                        $this->moveUp();
+                        break;
+                    case "\033[B": // Pfeil runter
+                        $this->moveDown();
+                        break;
+                    case "\n": // Enter
+                    case "\r":
+                        return $this->selectCurrentItem();
+                    case "\033": // ESC
+                        return null;
+                    case 'q':
+                    case 'Q':
+                        return null;
+                }
+            }
+        } finally {
+            $this->setRawMode(false);
+        }
+    }
+
+    /**
+     * Rendert das Menü auf dem Bildschirm.
+     */
+    private function renderMenu(): void
+    {
+        // Verwende den ScreenManager anstelle des direkten clearScreen()
+        $this->output->screen()->newMenu();
+
+        if ($this->title) {
+            $this->output->writeLine($this->title, ConsoleColor::BRIGHT_CYAN);
+            $this->output->writeLine(str_repeat('=', strlen($this->title)));
+            $this->output->writeLine('');
+        }
+
+        foreach ($this->menuItems as $index => $item) {
+            if (isset($item['separator'])) {
+                $this->output->writeLine($item['label'], ConsoleColor::GRAY);
+                continue;
+            }
+
+            $isSelected = ($index === $this->selectedIndex);
+            $prefix = $isSelected ? '► ' : '  ';
+            $color = $isSelected ? ConsoleColor::BRIGHT_YELLOW : null;
+
+            $number = $this->showNumbers ? ($index + 1) . '. ' : '';
+            $this->output->writeLine($prefix . $number . $item['label'], $color);
+        }
+
+        $this->output->writeLine('');
+        $this->output->writeLine('Verwenden Sie ↑/↓ zum Navigieren, Enter zum Auswählen, ESC/Q zum Beenden', ConsoleColor::GRAY);
+    }
+
+    /**
+     * Bewegt die Auswahl nach oben.
+     */
+    private function moveUp(): void
+    {
+        do {
+            $this->selectedIndex = ($this->selectedIndex - 1 + count($this->menuItems)) % count($this->menuItems);
+        } while (isset($this->menuItems[$this->selectedIndex]['separator']) && count($this->menuItems) > 1);
+    }
+
+    /**
+     * Bewegt die Auswahl nach unten.
+     */
+    private function moveDown(): void
+    {
+        do {
+            $this->selectedIndex = ($this->selectedIndex + 1) % count($this->menuItems);
+        } while (isset($this->menuItems[$this->selectedIndex]['separator']) && count($this->menuItems) > 1);
+    }
+
+    /**
+     * Wählt den aktuellen Menüpunkt aus.
+     */
+    private function selectCurrentItem(): mixed
+    {
+        $item = $this->menuItems[$this->selectedIndex];
+
+        if ($item['action']) {
+            return $item['action']();
+        }
+
+        return $item['value'];
+    }
+
+    /**
+     * Liest einen Tastendruck.
+     */
+    private function readKey(): string
+    {
+        $key = fgetc(STDIN);
+
+        // Behandle Escape-Sequenzen
+        if ($key === "\033") {
+            $key .= fgetc(STDIN);
+            if ($key === "\033[") {
+                $key .= fgetc(STDIN);
+            }
+        }
+
+        return $key;
+    }
+
+    /**
+     * Setzt den Terminal-Modus.
+     */
+    private function setRawMode(bool $enable): void
+    {
+        if ($enable) {
+            system('stty -echo -icanon min 1 time 0');
+        } else {
+            system('stty echo icanon');
+        }
+    }
+
+    // Die clearScreen-Methode wurde entfernt, da sie durch den ScreenManager ersetzt wurde.
+    // Verwende stattdessen $this->output->screen()->newScreen() oder $this->output->display()->clear().
+}
diff --git a/src/Framework/Console/Components/Table.php b/src/Framework/Console/Components/Table.php
new file mode 100644
index 00000000..a8b8435e
--- /dev/null
+++ b/src/Framework/Console/Components/Table.php
@@ -0,0 +1,205 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Console\Components;
+
+use App\Framework\Console\ConsoleStyle;
+use App\Framework\Console\ConsoleColor;
+use App\Framework\Console\ConsoleFormat;
+
+/**
+ * Rendert eine Tabelle in der Konsole.
+ */
+final class Table
+{
+    private array $headers = [];
+    private array $rows = [];
+    private array $columnWidths = [];
+    private int $padding = 1;
+
+    public function __construct(
+        private ?ConsoleStyle $headerStyle = null,
+        private ?ConsoleStyle $rowStyle = null,
+        private ?ConsoleStyle $borderStyle = null,
+        private bool $showBorders = true
+    ) {
+        $this->headerStyle ??= ConsoleStyle::create(color: ConsoleColor::BRIGHT_WHITE, format: ConsoleFormat::BOLD);
+        $this->rowStyle ??= ConsoleStyle::create();
+        $this->borderStyle ??= ConsoleStyle::create(color: ConsoleColor::GRAY);
+    }
+
+    /**
+     * Setzt die Spaltenüberschriften der Tabelle.
+     */
+    public function setHeaders(array $headers): self
+    {
+        $this->headers = $headers;
+        $this->calculateColumnWidths();
+        return $this;
+    }
+
+    /**
+     * Fügt eine Zeile zur Tabelle hinzu.
+     */
+    public function addRow(array $row): self
+    {
+        $this->rows[] = $row;
+        $this->calculateColumnWidths();
+        return $this;
+    }
+
+    /**
+     * Setzt alle Zeilen der Tabelle.
+     */
+    public function setRows(array $rows): self
+    {
+        $this->rows = $rows;
+        $this->calculateColumnWidths();
+        return $this;
+    }
+
+    /**
+     * Setzt den Innenabstand der Zellen.
+     */
+    public function setPadding(int $padding): self
+    {
+        $this->padding = max(0, $padding);
+        return $this;
+    }
+
+    /**
+     * Rendert die Tabelle und gibt den Text zurück.
+     */
+    public function render(): string
+    {
+        if (empty($this->headers) && empty($this->rows)) {
+            return '';
+        }
+
+        $output = '';
+
+        if ($this->showBorders) {
+            $output .= $this->renderBorder('top') . "\n";
+        }
+
+        // Header
+        if (!empty($this->headers)) {
+            $output .= $this->renderRow($this->headers, $this->headerStyle) . "\n";
+
+            if ($this->showBorders) {
+                $output .= $this->renderBorder('middle') . "\n";
+            }
+        }
+
+        // Zeilen
+        foreach ($this->rows as $index => $row) {
+            $output .= $this->renderRow($row, $this->rowStyle) . "\n";
+        }
+
+        if ($this->showBorders) {
+            $output .= $this->renderBorder('bottom') . "\n";
+        }
+
+        return $output;
+    }
+
+    /**
+     * Rendert eine Zeile der Tabelle.
+     */
+    private function renderRow(array $cells, ConsoleStyle $style): string
+    {
+        $output = '';
+
+        if ($this->showBorders) {
+            $output .= $this->borderStyle->apply('│');
+        }
+
+        foreach ($cells as $index => $cell) {
+            $width = $this->columnWidths[$index] ?? 10;
+            $cellText = (string)$cell;
+
+            // Linksbündige Ausrichtung mit exakter Breite
+            $paddedCell = str_pad($cellText, $width, ' ', STR_PAD_RIGHT);
+
+            // Padding hinzufügen
+            $padding = str_repeat(' ', $this->padding);
+            $finalCell = $padding . $paddedCell . $padding;
+
+            $output .= $style->apply($finalCell);
+
+            if ($this->showBorders) {
+                $output .= $this->borderStyle->apply('│');
+            }
+        }
+
+        return $output;
+    }
+
+    /**
+     * Rendert eine Trennlinie der Tabelle.
+     */
+    private function renderBorder(string $type): string
+    {
+        $left = match($type) {
+            'top' => '┌',
+            'middle' => '├',
+            'row' => '├',
+            'bottom' => '└',
+            default => '│'
+        };
+
+        $right = match($type) {
+            'top' => '┐',
+            'middle' => '┤',
+            'row' => '┤',
+            'bottom' => '┘',
+            default => '│'
+        };
+
+        $horizontal = '─';
+
+        $junction = match($type) {
+            'top' => '┬',
+            'middle' => '┼',
+            'row' => '┼',
+            'bottom' => '┴',
+            default => '│'
+        };
+
+        $border = $left;
+
+        foreach ($this->columnWidths as $index => $width) {
+            $cellWidth = $width + ($this->padding * 2);
+            $border .= str_repeat($horizontal, $cellWidth);
+
+            if ($index < count($this->columnWidths) - 1) {
+                $border .= $junction;
+            }
+        }
+
+        $border .= $right;
+
+        return $this->borderStyle->apply($border);
+    }
+
+    /**
+     * Berechnet die Breite jeder Spalte basierend auf dem Inhalt.
+     */
+    private function calculateColumnWidths(): void
+    {
+        $this->columnWidths = [];
+
+        // Header-Breiten
+        foreach ($this->headers as $index => $header) {
+            $this->columnWidths[$index] = mb_strlen((string)$header);
+        }
+
+        // Zeilen-Breiten
+        foreach ($this->rows as $row) {
+            foreach ($row as $index => $cell) {
+                $length = mb_strlen((string)$cell);
+                $this->columnWidths[$index] = max($this->columnWidths[$index] ?? 0, $length);
+            }
+        }
+    }
+}
diff --git a/src/Framework/Console/Components/TextBox.php b/src/Framework/Console/Components/TextBox.php
new file mode 100644
index 00000000..c09d424d
--- /dev/null
+++ b/src/Framework/Console/Components/TextBox.php
@@ -0,0 +1,124 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Console\Components;
+
+use App\Framework\Console\ConsoleStyle;
+use App\Framework\Console\ConsoleColor;
+use App\Framework\Console\ConsoleFormat;
+
+/**
+ * Rendert eine Textbox in der Konsole.
+ */
+final readonly class TextBox
+{
+    public function __construct(
+        private string        $content,
+        private int           $width = 80,
+        private int           $padding = 1,
+        private ?ConsoleStyle $borderStyle = null,
+        private ?ConsoleStyle $contentStyle = null,
+        private ?string       $title = null
+    ) {}
+
+    public function render(): string
+    {
+        $borderStyle = $this->borderStyle ?? ConsoleStyle::create(color: ConsoleColor::GRAY);
+        $contentStyle = $this->contentStyle ?? ConsoleStyle::create();
+
+        $contentWidth = $this->width - ($this->padding * 2) - 2;
+        $lines = $this->wrapText($this->content, $contentWidth);
+        $output = '';
+
+        // Obere Linie
+        if ($this->title) {
+            $titleLength = mb_strlen($this->title);
+            $availableSpace = $this->width - $titleLength - 6; // Abzug für '[ ]' und Ränder
+            $leftPadding = max(0, (int)floor($availableSpace / 2));
+            $rightPadding = max(0, $availableSpace - $leftPadding);
+
+            $output .= $borderStyle->apply('┌' . str_repeat('─', $leftPadding) . '[ ' . $this->title . ' ]' . str_repeat('─', $rightPadding) . '┐') . "\n";
+        } else {
+            $output .= $borderStyle->apply('┌' . str_repeat('─', $this->width - 2) . '┐') . "\n";
+        }
+
+        // Padding oben
+        for ($i = 0; $i < $this->padding; $i++) {
+            $output .= $borderStyle->apply('│') . str_repeat(' ', $this->width - 2) . $borderStyle->apply('│') . "\n";
+        }
+
+        // Inhalt
+        foreach ($lines as $line) {
+            $lineLength = mb_strlen($line);
+            $spaces = $contentWidth - $lineLength;
+            $paddedLine = $line . str_repeat(' ', $spaces);
+
+            $output .= $borderStyle->apply('│') .
+                      str_repeat(' ', $this->padding) .
+                      $contentStyle->apply($paddedLine) .
+                      str_repeat(' ', $this->padding) .
+                      $borderStyle->apply('│') . "\n";
+        }
+
+        // Padding unten
+        for ($i = 0; $i < $this->padding; $i++) {
+            $output .= $borderStyle->apply('│') . str_repeat(' ', $this->width - 2) . $borderStyle->apply('│') . "\n";
+        }
+
+        // Untere Linie
+        $output .= $borderStyle->apply('└' . str_repeat('─', $this->width - 2) . '┘') . "\n";
+
+        return $output;
+    }
+
+    private function wrapText(string $text, int $width): array
+    {
+        $lines = explode("\n", $text);
+        $wrapped = [];
+
+        foreach ($lines as $line) {
+            if (mb_strlen($line) <= $width) {
+                $wrapped[] = $line;
+            } else {
+                $wrapped = array_merge($wrapped, $this->splitTextIntoLines($line, $width));
+            }
+        }
+
+        // Leere Zeile hinzufügen, falls keine Inhalte vorhanden
+        if (empty($wrapped)) {
+            $wrapped[] = '';
+        }
+
+        return $wrapped;
+    }
+
+    private function splitTextIntoLines(string $text, int $width): array
+    {
+        $lines = [];
+        $words = explode(' ', $text);
+        $currentLine = '';
+
+        foreach ($words as $word) {
+            $testLine = empty($currentLine) ? $word : $currentLine . ' ' . $word;
+
+            if (mb_strlen($testLine) <= $width) {
+                $currentLine = $testLine;
+            } else {
+                if (!empty($currentLine)) {
+                    $lines[] = $currentLine;
+                    $currentLine = $word;
+                } else {
+                    // Wort ist länger als die Zeile - hart umbrechen
+                    $lines[] = mb_substr($word, 0, $width);
+                    $currentLine = mb_substr($word, $width);
+                }
+            }
+        }
+
+        if (!empty($currentLine)) {
+            $lines[] = $currentLine;
+        }
+
+        return $lines ?: [''];
+    }
+}
diff --git a/src/Framework/Console/Components/TreeHelper.php b/src/Framework/Console/Components/TreeHelper.php
new file mode 100644
index 00000000..f774a586
--- /dev/null
+++ b/src/Framework/Console/Components/TreeHelper.php
@@ -0,0 +1,215 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Console\Components;
+
+use App\Framework\Console\ConsoleStyle;
+use App\Framework\Console\ConsoleColor;
+use App\Framework\Console\ConsoleFormat;
+use App\Framework\Console\ConsoleOutput;
+
+/**
+ * TreeHelper zum Anzeigen hierarchischer Baumstrukturen in der Konsole.
+ * Ähnlich dem Symfony TreeHelper, aber angepasst an unser Styling-System.
+ */
+final class TreeHelper
+{
+    private string $prefix = '';
+    private bool $isLastElement = true;
+    private ?ConsoleStyle $nodeStyle = null;
+    private ?ConsoleStyle $leafStyle = null;
+    private ?ConsoleStyle $lineStyle = null;
+
+    /**
+     * @var array<array{title: string, node: ?self, isLeaf: bool}>
+     */
+    private array $nodes = [];
+
+    public function __construct(
+        private string $title = '',
+        private ConsoleOutput $output = new ConsoleOutput(),
+    ) {
+        $this->nodeStyle = ConsoleStyle::create(color: ConsoleColor::BRIGHT_YELLOW, format: ConsoleFormat::BOLD);
+        $this->leafStyle = ConsoleStyle::create(color: ConsoleColor::WHITE);
+        $this->lineStyle = ConsoleStyle::create(color: ConsoleColor::GRAY);
+    }
+
+    /**
+     * Setzt den Stil für Knotentitel (Verzeichnisse/Kategorien).
+     */
+    public function setNodeStyle(?ConsoleStyle $style): self
+    {
+        $this->nodeStyle = $style;
+        return $this;
+    }
+
+    /**
+     * Setzt den Stil für Blätter/Endpunkte.
+     */
+    public function setLeafStyle(?ConsoleStyle $style): self
+    {
+        $this->leafStyle = $style;
+        return $this;
+    }
+
+    /**
+     * Setzt den Stil für Baumlinien.
+     */
+    public function setLineStyle(?ConsoleStyle $style): self
+    {
+        $this->lineStyle = $style;
+        return $this;
+    }
+
+    /**
+     * Setzt den Haupttitel des Baums.
+     */
+    public function setTitle(string $title): self
+    {
+        $this->title = $title;
+        return $this;
+    }
+
+    /**
+     * Fügt einen Unterknoten (z.B. Unterverzeichnis) hinzu.
+     */
+    public function addNode(string $title): self
+    {
+        $node = new self($title);
+        $node->nodeStyle = $this->nodeStyle;
+        $node->leafStyle = $this->leafStyle;
+        $node->lineStyle = $this->lineStyle;
+
+        $this->nodes[] = [
+            'title' => $title,
+            'node' => $node,
+            'isLeaf' => false
+        ];
+
+        return $node;
+    }
+
+    /**
+     * Fügt einen Endpunkt (z.B. Datei) hinzu.
+     */
+    public function addLeaf(string $title): self
+    {
+        $this->nodes[] = [
+            'title' => $title,
+            'node' => null,
+            'isLeaf' => true
+        ];
+
+        return $this;
+    }
+
+    /**
+     * Zeigt die vollständige Baumstruktur an.
+     */
+    public function display(): void
+    {
+        if (!empty($this->title)) {
+            $this->output->writeLine($this->title, $this->nodeStyle);
+        }
+
+        $this->displayTree();
+    }
+
+    /**
+     * Rendert die Baumstruktur und gibt den Text zurück.
+     */
+    public function render(): string
+    {
+        $output = '';
+
+        if (!empty($this->title)) {
+            $output .= $this->nodeStyle->apply($this->title) . "\n";
+        }
+
+        $output .= $this->renderTree();
+
+        return $output;
+    }
+
+    /**
+     * Setzt den Präfix für die aktuelle Ebene.
+     * (Interne Methode für rekursives Rendern)
+     */
+    private function setPrefix(string $prefix, bool $isLastElement): self
+    {
+        $this->prefix = $prefix;
+        $this->isLastElement = $isLastElement;
+        return $this;
+    }
+
+    /**
+     * Zeigt die Baumstruktur mit dem aktuellen Präfix an.
+     * (Interne Methode für rekursives Rendern)
+     */
+    private function displayTree(): void
+    {
+        $count = count($this->nodes);
+
+        foreach ($this->nodes as $index => $item) {
+            $isLast = ($index === $count - 1);
+            $nodePrefix = $this->prefix . ($this->isLastElement ? '    ' : '│   ');
+
+            // Baumlinien und Verbindungen
+            $connector = $isLast ? '└── ' : '├── ';
+            $linePrefix = $this->prefix . $connector;
+
+            // Titel anzeigen
+            $style = $item['isLeaf'] ? $this->leafStyle : $this->nodeStyle;
+            $title = $linePrefix . $item['title'];
+
+            $this->output->writeLine(
+                $this->lineStyle->apply($linePrefix) .
+                $style->apply($item['title'])
+            );
+
+            // Unterelemente rekursiv anzeigen
+            if (!$item['isLeaf'] && $item['node'] !== null) {
+                $item['node']
+                    ->setPrefix($nodePrefix, $isLast)
+                    ->displayTree();
+            }
+        }
+    }
+
+    /**
+     * Rendert die Baumstruktur mit dem aktuellen Präfix und gibt den Text zurück.
+     * (Interne Methode für rekursives Rendern)
+     */
+    private function renderTree(): string
+    {
+        $output = '';
+        $count = count($this->nodes);
+
+        foreach ($this->nodes as $index => $item) {
+            $isLast = ($index === $count - 1);
+            $nodePrefix = $this->prefix . ($this->isLastElement ? '    ' : '│   ');
+
+            // Baumlinien und Verbindungen
+            $connector = $isLast ? '└── ' : '├── ';
+            $linePrefix = $this->prefix . $connector;
+
+            // Titel formatieren
+            $style = $item['isLeaf'] ? $this->leafStyle : $this->nodeStyle;
+            $title = $item['title'];
+
+            $output .= $this->lineStyle->apply($linePrefix) .
+                      $style->apply($title) . "\n";
+
+            // Unterelemente rekursiv rendern
+            if (!$item['isLeaf'] && $item['node'] !== null) {
+                $childOutput = $item['node']
+                    ->setPrefix($nodePrefix, $isLast)
+                    ->renderTree();
+
+                $output .= $childOutput;
+            }
+        }
+
+        return $output;
+    }
+}
diff --git a/src/Framework/Console/ConsoleApplication.php b/src/Framework/Console/ConsoleApplication.php
new file mode 100644
index 00000000..95ce5489
--- /dev/null
+++ b/src/Framework/Console/ConsoleApplication.php
@@ -0,0 +1,168 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Console;
+
+use App\Framework\Console\Components\InteractiveMenu;
+use App\Framework\Console\Exceptions\CommandNotFoundException;
+use App\Framework\DI\Container;
+use App\Framework\Discovery\Results\DiscoveryResults;
+use ReflectionClass;
+use ReflectionMethod;
+use Throwable;
+
+final class ConsoleApplication
+{
+    private array $commands = [];
+    private ConsoleOutputInterface $output;
+
+    public function __construct(
+        private readonly Container $container,
+        private readonly string    $scriptName = 'console',
+        private readonly string    $title = 'Console Application',
+        ?ConsoleOutputInterface    $output = null,
+
+    ) {
+        $this->output = $output ?? new ConsoleOutput();
+
+        // Setze den Fenstertitel
+        $this->output->writeWindowTitle($this->title);
+
+        $results = $this->container->get(DiscoveryResults::class);
+
+        foreach($results->get(ConsoleCommand::class) as $command) {
+
+            $this->commands[$command['attribute_data']['name']] = [
+                'instance' => $this->container->get($command['class']),
+                'method' => $command['method'],
+                'description' => $command['attribute_data']['description'] ?? ['Keine Beschreibung verfügbar'],
+                'reflection' => new ReflectionMethod($command['class'], $command['method'])
+            ];
+        }
+    }
+
+    /**
+     * Registriert alle Kommandos aus einer Klasse
+     */
+
+    public function registerCommands(object $commandClass): void
+    {
+        $reflection = new ReflectionClass($commandClass);
+
+        foreach ($reflection->getMethods(ReflectionMethod::IS_PUBLIC) as $method) {
+            $attributes = $method->getAttributes(ConsoleCommand::class);
+
+            foreach ($attributes as $attribute) {
+                /** @var ConsoleCommand $command */
+                $command = $attribute->newInstance();
+
+                $this->commands[$command->name] = [
+                    'instance' => $commandClass,
+                    'method' => $method->getName(),
+                    'description' => $command->description,
+                    'reflection' => $method
+                ];
+            }
+        }
+    }
+
+
+    /**
+     * Führt ein Kommando aus
+     */
+    public function run(array $argv): int
+    {
+        if (count($argv) < 2) {
+            $this->showHelp();
+            return ExitCode::SUCCESS->value;
+        }
+
+        $commandName = $argv[1];
+        $arguments = array_slice($argv, 2);
+
+        if (in_array($commandName, ['help', '--help', '-h'])) {
+            $this->showHelp();
+            return ExitCode::SUCCESS->value;
+        }
+
+        if (!isset($this->commands[$commandName])) {
+            $this->output->writeError("Kommando '{$commandName}' nicht gefunden.");
+            $this->showHelp();
+            return ExitCode::COMMAND_NOT_FOUND->value;
+        }
+
+        return $this->executeCommand($commandName, $arguments)->value;
+    }
+
+    private function executeCommand(string $commandName, array $arguments): ExitCode
+    {
+        $command = $this->commands[$commandName];
+        $instance = $command['instance'];
+        $method = $command['method'];
+
+        try {
+            // Setze den Fenstertitel für das aktuelle Kommando
+            $this->output->writeWindowTitle("{$this->scriptName} - {$commandName}");
+
+            // Erstelle ConsoleInput
+            $input = new ConsoleInput($arguments, $this->output);
+
+            // Führe das Kommando aus
+            $result = $instance->$method($input, $this->output);
+
+            // Behandle verschiedene Rückgabetypen
+            if ($result instanceof ExitCode) {
+                return $result;
+            }
+
+            if (is_int($result)) {
+                return ExitCode::from($result);
+            }
+
+            // Standardmäßig Erfolg, wenn nichts anderes zurückgegeben wird
+            return ExitCode::SUCCESS;
+
+        } catch (CommandNotFoundException $e) {
+            $this->output->writeError("Kommando nicht gefunden: " . $e->getMessage());
+            return ExitCode::COMMAND_NOT_FOUND;
+        } catch (Throwable $e) {
+            $this->output->writeError("Fehler beim Ausführen des Kommandos: " . $e->getMessage());
+
+            // Erweiterte Fehlerbehandlung basierend auf Exception-Typ
+            if ($e instanceof \InvalidArgumentException) {
+                return ExitCode::INVALID_INPUT;
+            }
+
+            if ($e instanceof \RuntimeException) {
+                return ExitCode::SOFTWARE_ERROR;
+            }
+
+            return ExitCode::GENERAL_ERROR;
+        }
+    }
+
+    private function showHelp(): void
+    {
+        $this->output->writeLine("Verfügbare Kommandos:", ConsoleColor::BRIGHT_CYAN);
+        $this->output->newLine();
+
+        $menu = new InteractiveMenu($this->output);
+        $menu->setTitle("Kommandos");
+
+        foreach ($this->commands as $name => $command) {
+
+            $description = $command['description'] ?: 'Keine Beschreibung verfügbar';
+
+            $menu->addItem($name, function () use ($name) {
+                return $this->executeCommand($name, [])->value;
+            }, $description);
+            #$this->output->writeLine(sprintf("  %-20s %s", $name, $description));
+        }
+
+        $this->output->writeLine("  " . $menu->showInteractive());
+
+        $this->output->newLine();
+        $this->output->writeLine("Verwendung:", ConsoleColor::BRIGHT_YELLOW);
+        $this->output->writeLine("  php {$this->scriptName} <kommando> [argumente]");
+    }
+}
diff --git a/src/Framework/Console/ConsoleColor.php b/src/Framework/Console/ConsoleColor.php
new file mode 100644
index 00000000..8b88cc3d
--- /dev/null
+++ b/src/Framework/Console/ConsoleColor.php
@@ -0,0 +1,52 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Console;
+
+/**
+ * Enum für Konsolen-Farben mit ANSI-Escape-Codes.
+ */
+enum ConsoleColor: string
+{
+    case RESET = "0";
+
+    // Einfache Textfarben
+    case BLACK = "30";
+    case RED = "31";
+    case GREEN = "32";
+    case YELLOW = "33";
+    case BLUE = "34";
+    case MAGENTA = "35";
+    case CYAN = "36";
+    case WHITE = "37";
+    case GRAY = "90";
+
+    // Helle Textfarben
+    case BRIGHT_RED = "91";
+    case BRIGHT_GREEN = "92";
+    case BRIGHT_YELLOW = "93";
+    case BRIGHT_BLUE = "94";
+    case BRIGHT_MAGENTA = "95";
+    case BRIGHT_CYAN = "96";
+    case BRIGHT_WHITE = "97";
+
+    // Hintergrundfarben
+    case BG_BLACK = "40";
+    case BG_RED = "41";
+    case BG_GREEN = "42";
+    case BG_YELLOW = "43";
+    case BG_BLUE = "44";
+    case BG_MAGENTA = "45";
+    case BG_CYAN = "46";
+    case BG_WHITE = "47";
+
+    // Kombinierte Farben
+    case WHITE_ON_RED = "97;41";
+    case BLACK_ON_YELLOW = "30;43";
+
+    public function toAnsi(): string
+    {
+        return "\033[{$this->value}m";
+    }
+
+}
diff --git a/src/Framework/Console/ConsoleCommand.php b/src/Framework/Console/ConsoleCommand.php
new file mode 100644
index 00000000..ec16d0b2
--- /dev/null
+++ b/src/Framework/Console/ConsoleCommand.php
@@ -0,0 +1,15 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Console;
+
+use Attribute;
+
+#[Attribute(\Attribute::TARGET_METHOD)]
+final readonly class ConsoleCommand
+{
+    public function __construct(
+        public string $name,
+        public string $description = ''
+    ) {}
+}
diff --git a/src/Framework/Console/ConsoleCommandMapper.php b/src/Framework/Console/ConsoleCommandMapper.php
new file mode 100644
index 00000000..a0d4571d
--- /dev/null
+++ b/src/Framework/Console/ConsoleCommandMapper.php
@@ -0,0 +1,24 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Console;
+
+use App\Framework\Core\AttributeMapper;
+
+final readonly class ConsoleCommandMapper implements AttributeMapper
+{
+    public function getAttributeClass(): string
+    {
+        return ConsoleCommand::class;
+    }
+
+    public function map(object $reflectionTarget, object $attributeInstance): ?array
+    {
+        return [
+            'name' => $attributeInstance->name,
+            'description' => $attributeInstance->description,
+            'class' => $reflectionTarget->getDeclaringClass()->getName(),
+            'method' => $reflectionTarget->getName(),
+        ];
+    }
+}
diff --git a/src/Framework/Console/ConsoleFormat.php b/src/Framework/Console/ConsoleFormat.php
new file mode 100644
index 00000000..e9fb0323
--- /dev/null
+++ b/src/Framework/Console/ConsoleFormat.php
@@ -0,0 +1,20 @@
+<?php
+
+namespace App\Framework\Console;
+
+enum ConsoleFormat: string
+{
+    case RESET = "0";
+    case BOLD = "1";
+    case DIM = "2";
+    case ITALIC = "3";
+    case UNDERLINE = "4";
+    case BLINK = "5";
+    case REVERSE = "7";
+    case STRIKETHROUGH = "9";
+
+    public function toAnsi(): string
+    {
+        return "\033[{$this->value}m";
+    }
+}
diff --git a/src/Framework/Console/ConsoleInput.php b/src/Framework/Console/ConsoleInput.php
new file mode 100644
index 00000000..a5c7ac35
--- /dev/null
+++ b/src/Framework/Console/ConsoleInput.php
@@ -0,0 +1,160 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Console;
+
+namespace App\Framework\Console;
+
+use App\Framework\Console\Components\InteractiveMenu;
+
+final class ConsoleInput implements ConsoleInputInterface
+{
+    private array $arguments;
+    private array $options = [];
+    private ?ConsoleOutputInterface $output = null;
+
+    public function __construct(array $arguments, ?ConsoleOutputInterface $output = null)
+    {
+        $this->parseArguments($arguments);
+        $this->output = $output ?? new ConsoleOutput();
+    }
+
+    private function parseArguments(array $arguments): void
+    {
+        $this->arguments = [];
+
+        foreach ($arguments as $arg) {
+            if (str_starts_with($arg, '--')) {
+                // Long option: --key=value oder --key
+                $parts = explode('=', substr($arg, 2), 2);
+                $this->options[$parts[0]] = $parts[1] ?? true;
+            } elseif (str_starts_with($arg, '-')) {
+                // Short option: -k value oder -k
+                $key = substr($arg, 1);
+                $this->options[$key] = true;
+            } else {
+                // Argument
+                $this->arguments[] = $arg;
+            }
+        }
+    }
+
+    public function getArgument(int $index, ?string $default = null): ?string
+    {
+        return $this->arguments[$index] ?? $default;
+    }
+
+    public function getArguments(): array
+    {
+        return $this->arguments;
+    }
+
+    public function getOption(string $name, mixed $default = null): mixed
+    {
+        return $this->options[$name] ?? $default;
+    }
+
+    public function hasOption(string $name): bool
+    {
+        return isset($this->options[$name]);
+    }
+
+    public function getOptions(): array
+    {
+        return $this->options;
+    }
+
+    /**
+     * Fragt nach einer Benutzereingabe.
+     */
+    public function ask(string $question, string $default = ''): string
+    {
+        return $this->output->askQuestion($question, $default);
+    }
+
+    /**
+     * Fragt nach einem Passwort (versteckte Eingabe).
+     */
+    public function askPassword(string $question): string
+    {
+        echo $question . ": ";
+
+        // Verstecke Eingabe
+        system('stty -echo');
+        $password = trim(fgets(STDIN));
+        system('stty echo');
+        echo PHP_EOL;
+
+        return $password;
+    }
+
+    /**
+     * Fragt nach einer Bestätigung (Ja/Nein).
+     */
+    public function confirm(string $question, bool $default = false): bool
+    {
+        return $this->output->confirm($question, $default);
+    }
+
+    /**
+     * Zeigt ein einfaches Auswahlmenü.
+     */
+    public function choice(string $question, array $choices, mixed $default = null): mixed
+    {
+        $menu = new InteractiveMenu($this->output);
+        $menu->setTitle($question);
+
+        foreach ($choices as $key => $choice) {
+            $menu->addItem($choice, null, $key);
+        }
+
+        return $menu->showSimple();
+    }
+
+    /**
+     * Zeigt ein interaktives Menü mit Pfeiltasten-Navigation.
+     */
+    public function menu(string $title, array $items): mixed
+    {
+        $menu = new InteractiveMenu($this->output);
+        $menu->setTitle($title);
+
+        foreach ($items as $key => $item) {
+            if ($item === '---') {
+                $menu->addSeparator();
+            } else {
+                $menu->addItem($item, null, $key);
+            }
+        }
+
+        return $menu->showInteractive();
+    }
+
+    /**
+     * Ermöglicht die Mehrfachauswahl aus einer Liste von Optionen.
+     */
+    public function multiSelect(string $question, array $options): array
+    {
+        $this->output->writeLine($question, ConsoleColor::BRIGHT_CYAN);
+        $this->output->writeLine("Mehrfachauswahl mit Komma getrennt (z.B. 1,3,5):");
+
+        foreach ($options as $key => $option) {
+            $this->output->writeLine("  " . ($key + 1) . ": {$option}");
+        }
+
+        $this->output->write("Ihre Auswahl: ", ConsoleColor::BRIGHT_CYAN);
+        $input = trim(fgets(STDIN));
+
+        $selected = [];
+        $indices = explode(',', $input);
+
+        foreach ($indices as $index) {
+            $index = (int)trim($index) - 1;
+            if (isset($options[$index])) {
+                $selected[] = $options[$index];
+            }
+        }
+
+        return $selected;
+    }
+}
diff --git a/src/Framework/Console/ConsoleInputInterface.php b/src/Framework/Console/ConsoleInputInterface.php
new file mode 100644
index 00000000..92303899
--- /dev/null
+++ b/src/Framework/Console/ConsoleInputInterface.php
@@ -0,0 +1,61 @@
+<?php
+
+namespace App\Framework\Console;
+
+interface ConsoleInputInterface
+{
+    /**
+     * Gibt ein Argument an der angegebenen Position zurück
+     */
+    public function getArgument(int $index, ?string $default = null): ?string;
+
+    /**
+     * Gibt alle Argumente zurück
+     */
+    public function getArguments(): array;
+
+    /**
+     * Gibt eine Option zurück
+     */
+    public function getOption(string $name, mixed $default = null): mixed;
+
+    /**
+     * Prüft, ob eine Option vorhanden ist
+     */
+    public function hasOption(string $name): bool;
+
+    /**
+     * Gibt alle Optionen zurück
+     */
+    public function getOptions(): array;
+
+    /**
+     * Fragt nach einer Benutzereingabe
+     */
+    public function ask(string $question, string $default = ''): string;
+
+    /**
+     * Fragt nach einem Passwort (versteckte Eingabe)
+     */
+    public function askPassword(string $question): string;
+
+    /**
+     * Fragt nach einer Bestätigung (Ja/Nein)
+     */
+    public function confirm(string $question, bool $default = false): bool;
+
+    /**
+     * Zeigt ein einfaches Auswahlmenü
+     */
+    public function choice(string $question, array $choices, mixed $default = null): mixed;
+
+    /**
+     * Zeigt ein interaktives Menü mit Pfeiltasten-Navigation
+     */
+    public function menu(string $title, array $items): mixed;
+
+    /**
+     * Ermöglicht die Mehrfachauswahl aus einer Liste von Optionen
+     */
+    public function multiSelect(string $question, array $options): array;
+}
diff --git a/src/Framework/Console/ConsoleOutput.php b/src/Framework/Console/ConsoleOutput.php
new file mode 100644
index 00000000..6964230d
--- /dev/null
+++ b/src/Framework/Console/ConsoleOutput.php
@@ -0,0 +1,166 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Console;
+
+use App\Framework\Console\Screen\Cursor;
+use App\Framework\Console\Screen\Display;
+use App\Framework\Console\Screen\ScreenManager;
+
+final readonly class ConsoleOutput implements ConsoleOutputInterface
+{
+    public Cursor $cursor;
+    public Display $display;
+    public ScreenManager $screen;
+
+    public function __construct()
+    {
+        $this->cursor = new Cursor($this);
+        $this->display = new Display($this);
+        $this->screen = new ScreenManager($this);
+    }
+
+    /**
+     * Gibt den Cursor-Controller zurück.
+     */
+    public function cursor(): Cursor
+    {
+        return $this->cursor;
+    }
+
+    /**
+     * Gibt den Display-Controller zurück.
+     */
+    public function display(): Display
+    {
+        return $this->display;
+    }
+
+    /**
+     * Gibt den ScreenManager zurück.
+     */
+    public function screen(): ScreenManager
+    {
+        return $this->screen;
+    }
+
+    /**
+     * Schreibt Text mit optionalem Stil.
+     */
+    public function write(string $message, ConsoleStyle|ConsoleColor|null $style = null): void
+    {
+        if ($style instanceof ConsoleColor) {
+            // Abwärtskompatibilität
+            echo $style->toAnsi() . $message . ConsoleColor::RESET->toAnsi();
+        } elseif ($style instanceof ConsoleStyle) {
+            echo $style->apply($message);
+        } else {
+            echo $message;
+        }
+    }
+
+    /**
+     * Schreibt rohe ANSI-Sequenzen ohne Verarbeitung.
+     */
+    public function writeRaw(string $raw): void
+    {
+        echo $raw;
+    }
+
+    /**
+     * Setzt den Fenstertitel.
+     */
+    public function writeWindowTitle(string $title, int $mode = 0): void
+    {
+        $this->writeRaw("\033]$mode;{$title}\007");
+    }
+
+    /**
+     * Schreibt eine Zeile mit optionalem Stil.
+     */
+    public function writeLine(string $message = '', ConsoleStyle|ConsoleColor|null $color = null): void
+    {
+        $this->write($message . PHP_EOL, $color);
+    }
+
+    /**
+     * Schreibt eine Erfolgsmeldung.
+     */
+    public function writeSuccess(string $message): void
+    {
+        $this->writeLine('✓ ' . $message, ConsoleStyle::success());
+    }
+
+    /**
+     * Schreibt eine Fehlermeldung.
+     */
+    public function writeError(string $message): void
+    {
+        $this->writeLine('✗ ' . $message, ConsoleStyle::error());
+    }
+
+    /**
+     * Schreibt eine Warnmeldung.
+     */
+    public function writeWarning(string $message): void
+    {
+        $this->writeLine('⚠ ' . $message, ConsoleStyle::warning());
+    }
+
+    /**
+     * Schreibt eine Infomeldung.
+     */
+    public function writeInfo(string $message): void
+    {
+        $this->writeLine('ℹ ' . $message, ConsoleStyle::info());
+    }
+
+    /**
+     * Fügt eine oder mehrere Leerzeilen ein.
+     */
+    public function newLine(int $count = 1): void
+    {
+        echo str_repeat(PHP_EOL, $count);
+    }
+
+    /**
+     * Stellt eine Frage und gibt die Antwort zurück.
+     */
+    public function askQuestion(string $question, ?string $default = null): string
+    {
+        $prompt = $question;
+        if ($default !== null) {
+            $prompt .= " [{$default}]";
+        }
+        $prompt .= ': ';
+
+        $this->write($prompt, ConsoleColor::BRIGHT_CYAN);
+
+        $answer = trim(fgets(STDIN));
+
+        return $answer === '' && $default !== null ? $default : $answer;
+    }
+
+    /**
+     * Stellt eine Ja/Nein-Frage.
+     */
+    public function confirm(string $question, bool $default = false): bool
+    {
+        $defaultText = $default ? 'Y/n' : 'y/N';
+        $answer = $this->askQuestion("{$question} [{$defaultText}]");
+
+        if ($answer === '') {
+            return $default;
+        }
+
+        return in_array(strtolower($answer), ['y', 'yes', 'ja', '1', 'true']);
+    }
+
+    /**
+     * Prüft, ob der Output zu einem Terminal geht.
+     */
+    public function isTerminal(): bool
+    {
+        return function_exists('posix_isatty') && posix_isatty(STDOUT);
+    }
+}
diff --git a/src/Framework/Console/ConsoleOutputInterface.php b/src/Framework/Console/ConsoleOutputInterface.php
new file mode 100644
index 00000000..c80267ba
--- /dev/null
+++ b/src/Framework/Console/ConsoleOutputInterface.php
@@ -0,0 +1,61 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Console;
+
+/**
+ * Interface für ConsoleOutput-Klassen.
+ */
+
+interface ConsoleOutputInterface
+{
+    /**
+     * Schreibt Text in die Konsole
+     */
+    public function write(string $message, ?ConsoleColor $color = null): void;
+
+    /**
+     * Schreibt Text mit Zeilenumbruch in die Konsole
+     */
+    public function writeLine(string $message = '', ?ConsoleColor $color = null): void;
+
+    /**
+     * Schreibt eine Erfolgsmeldung
+     */
+    public function writeSuccess(string $message): void;
+
+    /**
+     * Schreibt eine Fehlermeldung
+     */
+    public function writeError(string $message): void;
+
+    /**
+     * Schreibt eine Warnmeldung
+     */
+    public function writeWarning(string $message): void;
+
+    /**
+     * Schreibt eine Informationsmeldung
+     */
+    public function writeInfo(string $message): void;
+
+    /**
+     * Fügt leere Zeilen hinzu
+     */
+    public function newLine(int $count = 1): void;
+
+    /**
+     * Stellt eine Frage und wartet auf Benutzereingabe
+     */
+    public function askQuestion(string $question, ?string $default = null): string;
+
+    /**
+     * Fragt nach einer Bestätigung (ja/nein)
+     */
+    public function confirm(string $question, bool $default = false): bool;
+
+    /**
+     * Setzt den Fenstertitel des Terminals
+     */
+    public function writeWindowTitle(string $title, int $mode = 0): void;
+}
diff --git a/src/Framework/Console/ConsoleStyle.php b/src/Framework/Console/ConsoleStyle.php
new file mode 100644
index 00000000..31e3f3cf
--- /dev/null
+++ b/src/Framework/Console/ConsoleStyle.php
@@ -0,0 +1,89 @@
+<?php
+
+namespace App\Framework\Console;
+
+final readonly class ConsoleStyle
+{
+    public function __construct(
+        public ?ConsoleColor $color = null,
+        public ?ConsoleFormat $format = null,
+        public ?ConsoleColor $background = null,
+    ){}
+
+    /**
+     * Erstellt einen Style mit den gewünschten Eigenschaften.
+     */
+    public static function create(
+        ?ConsoleColor $color = null,
+        ?ConsoleFormat $format = null,
+        ?ConsoleColor $backgroundColor = null
+    ): self {
+        return new self($color, $format, $backgroundColor);
+    }
+
+    public function toAnsi(): string
+    {
+        $codes = [];
+
+        if ($this->format !== null) {
+            $codes[] = $this->format->value;
+        }
+
+        if ($this->color !== null) {
+            $codes[] = $this->color->value;
+        }
+
+        if ($this->background !== null) {
+            $codes[] = $this->background->value;
+        }
+
+        if (empty($codes)) {
+            return '';
+        }
+        return "\033[" . implode(';', $codes) . 'm';
+    }
+
+    /**
+     * Wendet den Style auf einen Text an.
+     */
+    public function apply(string $text): string
+    {
+        $ansi = $this->toAnsi();
+        if ($ansi === '') {
+            return $text;
+        }
+
+        return $ansi . $text . ConsoleColor::RESET->toAnsi();
+    }
+
+    // Vordefinierte Styles für häufige Anwendungen
+    public static function success(): self
+    {
+        return new self(ConsoleColor::BRIGHT_GREEN, ConsoleFormat::BOLD);
+    }
+
+    public static function error(): self
+    {
+        return new self(ConsoleColor::BRIGHT_RED, ConsoleFormat::BOLD);
+    }
+
+    public static function warning(): self
+    {
+        return new self(ConsoleColor::BRIGHT_YELLOW, ConsoleFormat::BOLD);
+    }
+
+    public static function info(): self
+    {
+        return new self(ConsoleColor::BRIGHT_BLUE);
+    }
+
+    public static function highlight(): self
+    {
+        return new self(format: ConsoleFormat::BOLD);
+    }
+
+    public static function dim(): self
+    {
+        return new self(format: ConsoleFormat::DIM);
+    }
+}
diff --git a/src/Framework/Console/DemoCommand.php b/src/Framework/Console/DemoCommand.php
new file mode 100644
index 00000000..e788bcb4
--- /dev/null
+++ b/src/Framework/Console/DemoCommand.php
@@ -0,0 +1,193 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Console;
+
+use App\Framework\Console\Components\InteractiveMenu;
+
+final readonly class DemoCommand
+{
+    #[ConsoleCommand('demo:hello', 'Zeigt eine einfache Hallo-Welt-Nachricht')]
+    public function hello(ConsoleInput $input, ConsoleOutput $output): int
+    {
+        $output->writeWindowTitle('Help Title', 2);
+
+        $name = $input->getArgument(0, 'Welt');
+
+        $output->writeLine("Hallo, {$name}!", ConsoleColor::BRIGHT_GREEN);
+
+        if ($input->hasOption('time')) {
+            $output->writeInfo('Aktuelle Zeit: ' . date('Y-m-d H:i:s'));
+        }
+
+        return 0;
+    }
+
+    #[ConsoleCommand('demo:colors', 'Zeigt alle verfügbaren Farben')]
+    public function colors(ConsoleInput $input, ConsoleOutput $output): int
+    {
+        $output->writeLine('Verfügbare Farben:', ConsoleColor::BRIGHT_WHITE);
+        $output->newLine();
+
+        $colors = [
+            'BLACK' => ConsoleColor::BLACK,
+            'RED' => ConsoleColor::RED,
+            'GREEN' => ConsoleColor::GREEN,
+            'YELLOW' => ConsoleColor::YELLOW,
+            'BLUE' => ConsoleColor::BLUE,
+            'MAGENTA' => ConsoleColor::MAGENTA,
+            'CYAN' => ConsoleColor::CYAN,
+            'WHITE' => ConsoleColor::WHITE,
+            'GRAY' => ConsoleColor::GRAY,
+        ];
+
+        foreach ($colors as $name => $color) {
+            $output->writeLine("  {$name}: Dies ist ein Test", $color);
+        }
+
+        $output->newLine();
+        $output->writeLine('Spezielle Ausgaben:');
+        $output->writeSuccess('Erfolg-Nachricht');
+        $output->writeError('Fehler-Nachricht');
+        $output->writeWarning('Warnung-Nachricht');
+        $output->writeInfo('Info-Nachricht');
+
+        return 0;
+    }
+
+    #[ConsoleCommand('demo:interactive', 'Interaktive Demo mit Benutzereingaben')]
+    public function interactive(ConsoleInput $input, ConsoleOutput $output): int
+    {
+        $output->writeLine('Interaktive Demo', ConsoleColor::BRIGHT_CYAN);
+        $output->newLine();
+
+        $name = $output->askQuestion('Wie ist Ihr Name?', 'Unbekannt');
+        $age = $output->askQuestion('Wie alt sind Sie?');
+        $confirmed = $output->confirm('Sind die Angaben korrekt?', true);
+
+        $output->newLine();
+        if ($confirmed) {
+            $output->writeSuccess("Hallo {$name}, Sie sind {$age} Jahre alt!");
+        } else {
+            $output->writeWarning('Vorgang abgebrochen.');
+        }
+
+        return 0;
+    }
+
+    #[ConsoleCommand('demo:menu', 'Zeigt ein interaktives Menü')]
+    public function menu(ConsoleInput $input, ConsoleOutput $output): int
+    {
+        $menu = new InteractiveMenu($output);
+
+        $result = $menu
+            ->setTitle('Hauptmenü - Demo Application')
+            ->addItem('Benutzer verwalten', function() use ($output) {
+                return $this->userMenu($output);
+            })
+            ->addItem('Einstellungen', function() use ($output) {
+                $output->writeInfo('Einstellungen werden geöffnet...');
+                return 'settings';
+            })
+            ->addSeparator()
+            ->addItem('Hilfe anzeigen', function() use ($output) {
+                $output->writeInfo('Hilfe wird angezeigt...');
+                return 'help';
+            })
+            ->addItem('Beenden', function() use ($output) {
+                $output->writeSuccess('Auf Wiedersehen!');
+                return 'exit';
+            })
+            ->showInteractive();
+
+        if ($result) {
+            $output->writeInfo("Menü-Rückgabe: {$result}");
+        }
+
+        return 0;
+    }
+
+    #[ConsoleCommand('demo:simple-menu', 'Zeigt ein einfaches Nummern-Menü')]
+    public function simpleMenu(ConsoleInput $input, ConsoleOutput $output): int
+    {
+        $menu = new InteractiveMenu($output);
+
+        $result = $menu
+            ->setTitle('Einfaches Menü')
+            ->addItem('Option 1')
+            ->addItem('Option 2')
+            ->addItem('Option 3')
+            ->showSimple();
+
+        $output->writeSuccess("Sie haben gewählt: {$result}");
+        return 0;
+    }
+
+    #[ConsoleCommand('demo:wizard', 'Zeigt einen Setup-Wizard')]
+    public function wizard(ConsoleInput $input, ConsoleOutput $output): int
+    {
+        $output->writeInfo('🧙 Setup-Wizard gestartet');
+        $output->newLine();
+
+        // Schritt 1: Grundeinstellungen
+        $output->writeLine('Schritt 1: Grundeinstellungen', ConsoleColor::BRIGHT_CYAN);
+        $appName = $input->ask('Name der Anwendung', 'Meine App');
+        $version = $input->ask('Version', '1.0.0');
+
+        // Schritt 2: Datenbank
+        $output->newLine();
+        $output->writeLine('Schritt 2: Datenbank-Konfiguration', ConsoleColor::BRIGHT_CYAN);
+        $dbHost = $input->ask('Datenbank-Host', 'localhost');
+        $dbName = $input->ask('Datenbank-Name', 'myapp');
+        $dbUser = $input->ask('Datenbank-Benutzer', 'root');
+        $dbPass = $input->askPassword('Datenbank-Passwort');
+
+        // Schritt 3: Features
+        $output->newLine();
+        $output->writeLine('Schritt 3: Features auswählen', ConsoleColor::BRIGHT_CYAN);
+        $features = $input->multiSelect('Welche Features möchten Sie aktivieren?', [
+            'Caching',
+            'Logging',
+            'Email-Versand',
+            'API-Schnittstelle',
+            'Admin-Panel'
+        ]);
+
+        // Zusammenfassung
+        $output->newLine();
+        $output->writeLine('🎯 Konfiguration abgeschlossen!', ConsoleColor::BRIGHT_GREEN);
+        $output->newLine();
+        $output->writeLine('Ihre Einstellungen:');
+        $output->writeLine("- App-Name: {$appName}");
+        $output->writeLine("- Version: {$version}");
+        $output->writeLine("- DB-Host: {$dbHost}");
+        $output->writeLine("- DB-Name: {$dbName}");
+        $output->writeLine("- Features: " . implode(', ', $features));
+
+        if ($input->confirm('Konfiguration speichern?', true)) {
+            $output->writeSuccess('✅ Konfiguration wurde gespeichert!');
+        } else {
+            $output->writeWarning('❌ Konfiguration wurde nicht gespeichert.');
+        }
+
+        return 0;
+    }
+
+    /**
+     * Hilfsmethode für das Benutzer-Untermenü.
+     */
+    private function userMenu(ConsoleOutput $output): string
+    {
+        $menu = new InteractiveMenu($output);
+
+        return $menu
+            ->setTitle('Benutzer-Verwaltung')
+            ->addItem('Benutzer auflisten', fn() => 'list_users')
+            ->addItem('Neuen Benutzer erstellen', fn() => 'create_user')
+            ->addItem('Benutzer bearbeiten', fn() => 'edit_user')
+            ->addItem('Benutzer löschen', fn() => 'delete_user')
+            ->addSeparator()
+            ->addItem('← Zurück zum Hauptmenü', fn() => 'back')
+            ->showInteractive() ?? 'back';
+    }
+}
diff --git a/src/Framework/Console/DemoCommand/ScreenDemoCommand.php b/src/Framework/Console/DemoCommand/ScreenDemoCommand.php
new file mode 100644
index 00000000..da2a7437
--- /dev/null
+++ b/src/Framework/Console/DemoCommand/ScreenDemoCommand.php
@@ -0,0 +1,173 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Console\DemoCommand;
+
+use App\Framework\Console\ConsoleCommand;
+use App\Framework\Console\ConsoleInput;
+use App\Framework\Console\ConsoleOutput;
+use App\Framework\Console\ConsoleStyle;
+use App\Framework\Console\Screen\ScreenType;
+
+
+final class ScreenDemoCommand
+{
+    #[ConsoleCommand('demo:screen', 'Zeigt die verschiedenen Screen-Management-Funktionen')]
+    public function __invoke(ConsoleInput $input, ConsoleOutput $output): int
+    {
+        // Aktiviere interaktiven Modus
+        $output->screen()->setInteractiveMode(true);
+
+        // Zeige ein Menü
+        $output->screen()->newMenu();
+        $output->writeLine('=== Screen-Management Demo ===', ConsoleStyle::success());
+        $output->writeLine('');
+        $output->writeLine('1. Cursor-Bewegungen');
+        $output->writeLine('2. Bildschirmlöschung');
+        $output->writeLine('3. Fortschrittsanzeige');
+        $output->writeLine('4. Typensatz-Beispiel');
+        $output->writeLine('');
+
+        $choice = $output->askQuestion('Wählen Sie eine Option (1-4)');
+
+        switch ($choice) {
+            case '1':
+                $this->demoCursor($input, $output);
+                break;
+            case '2':
+                $this->demoDisplay($input, $output);
+                break;
+            case '3':
+                $this->demoProgress($input, $output);
+                break;
+            case '4':
+                $this->demoTypeset($input, $output);
+                break;
+            default:
+                $output->writeError('Ungültige Auswahl!');
+        }
+
+        return 0;
+    }
+
+    private function demoCursor(ConsoleInput $input, ConsoleOutput $output): void
+    {
+        $output->screen()->newScreen(ScreenType::CONTENT);
+        $output->writeLine('=== Cursor-Bewegungs-Demo ===', ConsoleStyle::success());
+        $output->writeLine('');
+
+        // Cursor-Bewegungen
+        $output->writeLine('Der Cursor wird jetzt bewegt...');
+        sleep(1);
+
+        $output->cursor()->down(2)->right(5);
+        $output->write('Hallo!', ConsoleStyle::success());
+        sleep(1);
+
+        $output->cursor()->down(1)->left(5);
+        $output->write('Welt!', ConsoleStyle::info());
+        sleep(1);
+
+        $output->cursor()->moveTo(10, 20);
+        $output->write('Position 10,20', ConsoleStyle::warning());
+        sleep(1);
+
+        $output->cursor()->home();
+        $output->writeLine("\nZurück zum Anfang!", ConsoleStyle::error());
+        sleep(1);
+
+        $output->writeLine("\nDrücken Sie eine Taste, um fortzufahren...");
+        $output->screen()->waitForInput();
+    }
+
+    private function demoDisplay(ConsoleInput $input, ConsoleOutput $output): void
+    {
+        $output->screen()->newScreen(ScreenType::CONTENT);
+        $output->writeLine('=== Bildschirmlöschungs-Demo ===', ConsoleStyle::success());
+        $output->writeLine('');
+
+        // Bildschirm füllen
+        for ($i = 1; $i <= 10; $i++) {
+            $output->writeLine("Zeile $i: Dies ist ein Test");
+        }
+
+        sleep(1);
+        $output->writeLine("\nLösche in 3 Sekunden den Bildschirm...");
+        sleep(3);
+
+        // Bildschirm löschen
+        $output->display()->clear();
+        $output->writeLine('Bildschirm wurde gelöscht!');
+        sleep(1);
+
+        // Zeilen hinzufügen
+        for ($i = 1; $i <= 5; $i++) {
+            $output->writeLine("Neue Zeile $i");
+        }
+
+        sleep(1);
+        $output->writeLine("\nLösche nur die aktuelle Zeile in 2 Sekunden...");
+        sleep(2);
+
+        // Zeile löschen
+        $output->display()->clearLine();
+        $output->writeLine('Die Zeile wurde gelöscht und durch diese ersetzt!');
+
+        sleep(1);
+        $output->writeLine("\nDrücken Sie eine Taste, um fortzufahren...");
+        $output->screen()->waitForInput();
+    }
+
+    private function demoProgress(ConsoleInput $input, ConsoleOutput $output): void
+    {
+        $output->screen()->newScreen(ScreenType::PROGRESS);
+        $output->writeLine('=== Fortschrittsanzeige-Demo ===', ConsoleStyle::success());
+        $output->writeLine('');
+
+        $total = 20;
+
+        for ($i = 0; $i <= $total; $i++) {
+            $percent = floor(($i / $total) * 100);
+            $bar = str_repeat('█', $i) . str_repeat('░', $total - $i);
+
+            // Zeile löschen und neue Fortschrittsanzeige
+            $output->display()->clearLine();
+            $output->write("Fortschritt: [{$bar}] {$percent}%");
+
+            usleep(200000); // 200ms pause
+        }
+
+        $output->writeLine("\n\nFortschritt abgeschlossen!");
+        sleep(1);
+
+        $output->writeLine("\nDrücken Sie eine Taste, um fortzufahren...");
+        $output->screen()->waitForInput();
+    }
+
+    private function demoTypeset(ConsoleInput $input, ConsoleOutput $output): void
+    {
+        $output->screen()->newScreen(ScreenType::CONTENT);
+        $output->writeLine('=== Typensatz-Demo ===', ConsoleStyle::success());
+        $output->writeLine('');
+
+        $text = 'Dies ist eine Demonstration des Typensatz-Effekts. Der Text wird Zeichen für Zeichen angezeigt, ' .
+                'als ob er gerade getippt würde. Diese Technik kann für Intros, Tutorials oder ' .
+                'dramatische Effekte verwendet werden.';
+
+        // Typensatz-Effekt
+        foreach (str_split($text) as $char) {
+            $output->write($char);
+            usleep(rand(50000, 150000)); // 50-150ms zufällige Pause
+        }
+
+        $output->writeLine("\n\nTypensatz abgeschlossen!");
+        sleep(1);
+
+        $output->writeLine("\nDrücken Sie eine Taste, um zurückzukehren...");
+        $output->screen()->waitForInput();
+
+        // Zurück zum Hauptmenü
+        $output->screen()->newMenu();
+        $this->__invoke($input, $output);
+    }
+}
diff --git a/src/Framework/Console/Examples/ProgressBarExample.php b/src/Framework/Console/Examples/ProgressBarExample.php
new file mode 100644
index 00000000..189c102c
--- /dev/null
+++ b/src/Framework/Console/Examples/ProgressBarExample.php
@@ -0,0 +1,50 @@
+<?php
+
+namespace App\Framework\Console\Examples;
+
+use App\Framework\Console\ConsoleCommand;
+use App\Framework\Console\ConsoleInput;
+use App\Framework\Console\ConsoleOutput;
+use App\Framework\Console\ProgressBar;
+
+class ProgressBarExample
+{
+    #[ConsoleCommand(name: 'demo:progressbar', description: 'Zeigt eine Demonstration der Fortschrittsanzeige')]
+    public function showProgressBarDemo(ConsoleInput $input, ConsoleOutput $output): int
+    {
+        $output->writeInfo('Demonstration der Fortschrittsanzeige');
+        $output->newLine();
+
+        // Einfache Fortschrittsanzeige
+        $output->writeLine('Einfache Fortschrittsanzeige:');
+        $progress = new ProgressBar($output, 10);
+        $progress->start();
+
+        for ($i = 0; $i < 10; $i++) {
+            // Simuliere Arbeit
+            usleep(200000);
+            $progress->advance();
+        }
+
+        $progress->finish();
+
+        // Fortschrittsanzeige mit angepasstem Format
+        $output->writeLine('Fortschrittsanzeige mit angepasstem Format:');
+        $progress = new ProgressBar($output, 5);
+        $progress->setFormat('%bar% %current%/%total% [%percent%%] - %elapsed%s vergangen, %remaining%s verbleibend');
+        $progress->setBarCharacters('█', '░', '█');
+        $progress->start();
+
+        for ($i = 0; $i < 5; $i++) {
+            // Simuliere Arbeit
+            usleep(500000);
+            $progress->advance();
+        }
+
+        $progress->finish();
+
+        $output->writeSuccess('Demonstration abgeschlossen!');
+
+        return 0;
+    }
+}
diff --git a/src/Framework/Console/Examples/SpinnerExample.php b/src/Framework/Console/Examples/SpinnerExample.php
new file mode 100644
index 00000000..37f78510
--- /dev/null
+++ b/src/Framework/Console/Examples/SpinnerExample.php
@@ -0,0 +1,72 @@
+<?php
+
+namespace App\Framework\Console\Examples;
+
+use App\Framework\Console\ConsoleCommand;
+use App\Framework\Console\ConsoleInput;
+use App\Framework\Console\ConsoleOutput;
+use App\Framework\Console\Spinner;
+use App\Framework\Console\SpinnerStyle;
+
+class SpinnerExample
+{
+    #[ConsoleCommand(name: 'demo:spinner', description: 'Zeigt eine Demonstration der Spinner-Komponente')]
+    public function showSpinnerDemo(ConsoleInput $input, ConsoleOutput $output): int
+    {
+        $output->writeInfo('Demonstration der Spinner-Komponente');
+        $output->newLine();
+
+        // Einfacher Spinner
+        $spinner = new Spinner($output, 'Lade Daten...');
+        $spinner->start();
+
+        // Simuliere Arbeit
+        for ($i = 0; $i < 10; $i++) {
+            usleep(100000);
+            $spinner->update();
+        }
+
+        $spinner->success('Daten erfolgreich geladen!');
+
+        // Spinner mit verschiedenen Stilen
+        $styles = [
+            SpinnerStyle::DOTS,
+            SpinnerStyle::LINE,
+            SpinnerStyle::BOUNCE,
+            SpinnerStyle::ARROW
+        ];
+
+        foreach ($styles as $style) {
+            $output->writeLine("Spinner-Stil: {$style->name}");
+            $spinner = new Spinner($output, 'Verarbeite...', $style);
+            $spinner->start();
+
+            for ($i = 0; $i < 15; $i++) {
+                usleep(100000);
+
+                if ($i === 5) {
+                    $spinner->setMessage('Fast fertig...');
+                }
+
+                $spinner->update();
+            }
+
+            $spinner->success('Fertig!');
+        }
+
+        // Fehlerhafter Prozess
+        $spinner = new Spinner($output, 'Verbinde mit Server...');
+        $spinner->start();
+
+        for ($i = 0; $i < 8; $i++) {
+            usleep(150000);
+            $spinner->update();
+        }
+
+        $spinner->error('Verbindung fehlgeschlagen!');
+
+        $output->writeSuccess('Demonstration abgeschlossen!');
+
+        return 0;
+    }
+}
diff --git a/src/Framework/Console/Examples/TableExample.php b/src/Framework/Console/Examples/TableExample.php
new file mode 100644
index 00000000..7c0f2b66
--- /dev/null
+++ b/src/Framework/Console/Examples/TableExample.php
@@ -0,0 +1,60 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Console\Examples;
+
+use App\Framework\Console\Components\Table;
+use App\Framework\Console\ConsoleCommand;
+use App\Framework\Console\ConsoleColor;
+use App\Framework\Console\ConsoleFormat;
+use App\Framework\Console\ConsoleInput;
+use App\Framework\Console\ConsoleOutput;
+use App\Framework\Console\ConsoleStyle;
+
+final class TableExample
+{
+    #[ConsoleCommand('demo:table', 'Zeigt eine Beispiel-Tabelle')]
+    public function showTable(ConsoleInput $input, ConsoleOutput $output): int
+    {
+        $output->writeLine('Beispiel für die Table-Komponente', ConsoleStyle::create(
+            color: ConsoleColor::BRIGHT_WHITE,
+            format: ConsoleFormat::BOLD
+        ));
+        $output->newLine();
+
+        // Einfache Tabelle
+        $table = new Table(
+            headerStyle: ConsoleStyle::create(color: ConsoleColor::BRIGHT_YELLOW, format: ConsoleFormat::BOLD),
+            borderStyle: ConsoleStyle::create(color: ConsoleColor::CYAN)
+        );
+
+        $table->setHeaders(['Name', 'Alter', 'Stadt'])
+              ->addRow(['Max Mustermann', '30', 'Berlin'])
+              ->addRow(['Anna Schmidt', '25', 'München'])
+              ->addRow(['Peter Weber', '35', 'Hamburg']);
+
+        $output->write($table->render());
+        $output->newLine();
+
+        // Komplexere Tabelle mit Produktdaten
+        $output->writeLine('Produktübersicht:', ConsoleStyle::create(color: ConsoleColor::BRIGHT_GREEN));
+
+        $productTable = new Table(
+            headerStyle: ConsoleStyle::create(color: ConsoleColor::BRIGHT_WHITE, format: ConsoleFormat::BOLD),
+            rowStyle: ConsoleStyle::create(color: ConsoleColor::WHITE),
+            borderStyle: ConsoleStyle::create(color: ConsoleColor::GRAY)
+        );
+
+        $productTable->setHeaders(['Artikel-Nr.', 'Bezeichnung', 'Preis', 'Lagerbestand', 'Status'])
+                     ->setPadding(2)
+                     ->addRow(['A-1001', 'Tastatur Deluxe', '89,99 €', '45', 'Verfügbar'])
+                     ->addRow(['A-1002', 'Gaming Maus Pro', '69,99 €', '12', 'Knapp'])
+                     ->addRow(['A-1003', '4K Monitor 27"', '349,99 €', '0', 'Ausverkauft'])
+                     ->addRow(['A-1004', 'USB-C Kabel 2m', '19,99 €', '156', 'Verfügbar'])
+                     ->addRow(['A-1005', 'Wireless Headset', '129,99 €', '8', 'Knapp']);
+
+        $output->write($productTable->render());
+
+        return 0;
+    }
+}
diff --git a/src/Framework/Console/Examples/TextBoxExample.php b/src/Framework/Console/Examples/TextBoxExample.php
new file mode 100644
index 00000000..514ed006
--- /dev/null
+++ b/src/Framework/Console/Examples/TextBoxExample.php
@@ -0,0 +1,64 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Console\Examples;
+
+use App\Framework\Console\Components\TextBox;
+use App\Framework\Console\ConsoleCommand;
+use App\Framework\Console\ConsoleColor;
+use App\Framework\Console\ConsoleFormat;
+use App\Framework\Console\ConsoleInput;
+use App\Framework\Console\ConsoleOutput;
+use App\Framework\Console\ConsoleStyle;
+
+final class TextBoxExample
+{
+    #[ConsoleCommand('demo:textbox', 'Zeigt verschiedene TextBox-Beispiele')]
+    public function showTextBox(ConsoleInput $input, ConsoleOutput $output): int
+    {
+        $output->writeLine('Beispiele für die TextBox-Komponente', ConsoleStyle::create(
+            color: ConsoleColor::BRIGHT_WHITE,
+            format: ConsoleFormat::BOLD
+        ));
+        $output->newLine();
+
+        // Einfache TextBox
+        $infoBox = new TextBox(
+            content: "Dies ist eine einfache Informationsbox.\nSie kann mehrere Zeilen enthalten und passt den Text automatisch an die Breite an.",
+            width: 60,
+            borderStyle: ConsoleStyle::create(color: ConsoleColor::BRIGHT_BLUE),
+            contentStyle: ConsoleStyle::create(color: ConsoleColor::WHITE),
+            title: "Information"
+        );
+
+        $output->write($infoBox->render());
+        $output->newLine();
+
+        // Warnung TextBox
+        $warningBox = new TextBox(
+            content: "Warnung! Diese Aktion kann nicht rückgängig gemacht werden. Stellen Sie sicher, dass Sie ein Backup Ihrer Daten haben, bevor Sie fortfahren.",
+            width: 70,
+            padding: 2,
+            borderStyle: ConsoleStyle::create(color: ConsoleColor::BRIGHT_YELLOW),
+            contentStyle: ConsoleStyle::create(color: ConsoleColor::BRIGHT_WHITE),
+            title: "⚠ Warnung"
+        );
+
+        $output->write($warningBox->render());
+        $output->newLine();
+
+        // Fehler TextBox
+        $errorBox = new TextBox(
+            content: "Fehler: Die Verbindung zur Datenbank konnte nicht hergestellt werden. Überprüfen Sie Ihre Zugangsdaten und stellen Sie sicher, dass der Datenbankserver läuft.",
+            width: 80,
+            padding: 1,
+            borderStyle: ConsoleStyle::create(color: ConsoleColor::BRIGHT_RED),
+            contentStyle: ConsoleStyle::create(color: ConsoleColor::BRIGHT_WHITE),
+            title: "✗ Fehler"
+        );
+
+        $output->write($errorBox->render());
+
+        return 0;
+    }
+}
diff --git a/src/Framework/Console/Examples/TreeExample.php b/src/Framework/Console/Examples/TreeExample.php
new file mode 100644
index 00000000..c0d55415
--- /dev/null
+++ b/src/Framework/Console/Examples/TreeExample.php
@@ -0,0 +1,89 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Console\Examples;
+
+use App\Framework\Console\Components\TreeHelper;
+use App\Framework\Console\ConsoleCommand;
+use App\Framework\Console\ConsoleColor;
+use App\Framework\Console\ConsoleFormat;
+use App\Framework\Console\ConsoleInput;
+use App\Framework\Console\ConsoleOutput;
+use App\Framework\Console\ConsoleStyle;
+
+final class TreeExample
+{
+    #[ConsoleCommand('demo:tree', 'Zeigt ein Beispiel für die TreeHelper-Komponente')]
+    public function showTreeExample(ConsoleInput $input, ConsoleOutput $output): int
+    {
+        $output->writeLine('Beispiel für den TreeHelper', ConsoleStyle::create(
+            color: ConsoleColor::BRIGHT_WHITE,
+            format: ConsoleFormat::BOLD
+        ));
+        $output->newLine();
+
+        // Einfaches Verzeichnisbeispiel
+        $tree = new TreeHelper('Projektstruktur');
+        $tree->setNodeStyle(ConsoleStyle::create(color: ConsoleColor::BRIGHT_CYAN, format: ConsoleFormat::BOLD));
+        $tree->setLeafStyle(ConsoleStyle::create(color: ConsoleColor::WHITE));
+
+        $srcNode = $tree->addNode('src/');
+
+        $domainNode = $srcNode->addNode('Domain/');
+        $domainNode->addNode('User/')->addLeaf('User.php')->addLeaf('UserRepository.php');
+        $domainNode->addNode('Product/')->addLeaf('Product.php')->addLeaf('ProductRepository.php');
+
+        $frameworkNode = $srcNode->addNode('Framework/');
+        $consoleNode = $frameworkNode->addNode('Console/');
+        $consoleNode->addNode('Components/')
+            ->addLeaf('Table.php')
+            ->addLeaf('TextBox.php')
+            ->addLeaf('TreeHelper.php');
+
+        $consoleNode->addLeaf('ConsoleColor.php');
+        $consoleNode->addLeaf('ConsoleFormat.php');
+        $consoleNode->addLeaf('ConsoleOutput.php');
+
+        $testNode = $tree->addNode('tests/');
+        $testNode->addLeaf('UserTest.php');
+        $testNode->addLeaf('ProductTest.php');
+
+        $tree->addLeaf('composer.json');
+        $tree->addLeaf('README.md');
+
+        $output->write($tree->render());
+        $output->newLine(2);
+
+        // Zweites Beispiel: Kategorien
+        $output->writeLine('Kategorie-Baum:', ConsoleStyle::create(color: ConsoleColor::BRIGHT_GREEN));
+
+        $categories = new TreeHelper();
+        $categories->setNodeStyle(ConsoleStyle::create(color: ConsoleColor::BRIGHT_YELLOW, format: ConsoleFormat::BOLD));
+        $categories->setLeafStyle(ConsoleStyle::create(color: ConsoleColor::BRIGHT_WHITE));
+        $categories->setLineStyle(ConsoleStyle::create(color: ConsoleColor::GRAY));
+
+        $electronics = $categories->addNode('Elektronik');
+
+        $computers = $electronics->addNode('Computer & Zubehör');
+        $computers->addLeaf('Laptops');
+        $computers->addLeaf('Desktop-PCs');
+        $peripherie = $computers->addNode('Peripheriegeräte');
+        $peripherie->addLeaf('Monitore');
+        $peripherie->addLeaf('Tastaturen');
+        $peripherie->addLeaf('Mäuse');
+
+        $smartphones = $electronics->addNode('Smartphones & Zubehör');
+        $smartphones->addLeaf('Handys');
+        $smartphones->addLeaf('Hüllen');
+        $smartphones->addLeaf('Ladegeräte');
+
+        $kleidung = $categories->addNode('Kleidung');
+        $kleidung->addLeaf('Herren');
+        $kleidung->addLeaf('Damen');
+        $kleidung->addLeaf('Kinder');
+
+        $output->write($categories->render());
+
+        return 0;
+    }
+}
diff --git a/src/Framework/Console/Exceptions/CommandNotFoundException.php b/src/Framework/Console/Exceptions/CommandNotFoundException.php
new file mode 100644
index 00000000..ccb1fcc1
--- /dev/null
+++ b/src/Framework/Console/Exceptions/CommandNotFoundException.php
@@ -0,0 +1,11 @@
+<?php
+
+namespace App\Framework\Console\Exceptions;
+
+class CommandNotFoundException extends ConsoleException
+{
+    public function __construct(string $commandName)
+    {
+        parent::__construct("Kommando '{$commandName}' nicht gefunden.");
+    }
+}
diff --git a/src/Framework/Console/Exceptions/ConsoleException.php b/src/Framework/Console/Exceptions/ConsoleException.php
new file mode 100644
index 00000000..c963b38e
--- /dev/null
+++ b/src/Framework/Console/Exceptions/ConsoleException.php
@@ -0,0 +1,7 @@
+<?php
+
+namespace App\Framework\Console\Exceptions;
+
+class ConsoleException extends \Exception
+{
+}
diff --git a/src/Framework/Console/ExitCode.php b/src/Framework/Console/ExitCode.php
new file mode 100644
index 00000000..69f8e9be
--- /dev/null
+++ b/src/Framework/Console/ExitCode.php
@@ -0,0 +1,74 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Console;
+
+/**
+ * Standard Exit-Codes für Console-Anwendungen
+ *
+ * Basiert auf den POSIX-Standards und bewährten Praktiken:
+ * - 0: Erfolg
+ * - 1: Allgemeiner Fehler
+ * - 2: Falsche Verwendung (ungültige Argumente)
+ * - 64-78: Spezifische Fehler-Codes (sysexits.h Standard)
+ */
+enum ExitCode: int
+{
+    case SUCCESS = 0;
+    case GENERAL_ERROR = 1;
+    case USAGE_ERROR = 2;
+    case COMMAND_NOT_FOUND = 64;
+    case INVALID_INPUT = 65;
+    case NO_INPUT = 66;
+    case UNAVAILABLE = 69;
+    case SOFTWARE_ERROR = 70;
+    case OS_ERROR = 71;
+    case OS_FILE_ERROR = 72;
+    case CANT_CREATE = 73;
+    case IO_ERROR = 74;
+    case TEMP_FAIL = 75;
+    case PROTOCOL_ERROR = 76;
+    case NO_PERMISSION = 77;
+    case CONFIG_ERROR = 78;
+
+    /**
+     * Gibt eine menschenlesbare Beschreibung des Exit-Codes zurück
+     */
+    public function getDescription(): string
+    {
+        return match($this) {
+            self::SUCCESS => 'Erfolgreich abgeschlossen',
+            self::GENERAL_ERROR => 'Allgemeiner Fehler',
+            self::USAGE_ERROR => 'Falsche Verwendung oder ungültige Argumente',
+            self::COMMAND_NOT_FOUND => 'Kommando nicht gefunden',
+            self::INVALID_INPUT => 'Ungültige Eingabedaten',
+            self::NO_INPUT => 'Keine Eingabe vorhanden',
+            self::UNAVAILABLE => 'Service nicht verfügbar',
+            self::SOFTWARE_ERROR => 'Interner Software-Fehler',
+            self::OS_ERROR => 'Betriebssystem-Fehler',
+            self::OS_FILE_ERROR => 'Datei-/Verzeichnis-Fehler',
+            self::CANT_CREATE => 'Kann Datei/Verzeichnis nicht erstellen',
+            self::IO_ERROR => 'Ein-/Ausgabe-Fehler',
+            self::TEMP_FAIL => 'Temporärer Fehler',
+            self::PROTOCOL_ERROR => 'Protokoll-Fehler',
+            self::NO_PERMISSION => 'Keine Berechtigung',
+            self::CONFIG_ERROR => 'Konfigurationsfehler',
+        };
+    }
+
+    /**
+     * Prüft, ob der Exit-Code einen Erfolg darstellt
+     */
+    public function isSuccess(): bool
+    {
+        return $this === self::SUCCESS;
+    }
+
+    /**
+     * Prüft, ob der Exit-Code einen Fehler darstellt
+     */
+    public function isError(): bool
+    {
+        return !$this->isSuccess();
+    }
+}
diff --git a/src/Framework/Console/ProgressBar.php b/src/Framework/Console/ProgressBar.php
new file mode 100644
index 00000000..73ad9265
--- /dev/null
+++ b/src/Framework/Console/ProgressBar.php
@@ -0,0 +1,185 @@
+<?php
+
+namespace App\Framework\Console;
+
+class ProgressBar
+{
+    private ConsoleOutputInterface $output;
+    private int $total;
+    private int $current = 0;
+    private int $width;
+    private float $startTime;
+    private string $format = '%bar% %percent%%';
+    private string $barChar = '=';
+    private string $emptyBarChar = '-';
+    private string $progressChar = '>';
+    private int $redrawFrequency = 1;
+    private int $writeCount = 0;
+    private bool $firstRun = true;
+
+    public function __construct(ConsoleOutputInterface $output, int $total = 100, int $width = 50)
+    {
+        $this->output = $output;
+        $this->total = max(1, $total);
+        $this->width = $width;
+        $this->startTime = microtime(true);
+    }
+
+    /**
+     * Setzt das Format der Fortschrittsanzeige
+     * Verfügbare Platzhalter:
+     * - %bar%: Die Fortschrittsanzeige
+     * - %current%: Aktueller Fortschritt
+     * - %total%: Gesamtwert
+     * - %percent%: Prozentsatz des Fortschritts
+     * - %elapsed%: Verstrichene Zeit in Sekunden
+     * - %remaining%: Geschätzte verbleibende Zeit in Sekunden
+     */
+    public function setFormat(string $format): self
+    {
+        $this->format = $format;
+        return $this;
+    }
+
+    /**
+     * Setzt die Zeichen für die Fortschrittsanzeige
+     */
+    public function setBarCharacters(string $barChar = '=', string $emptyBarChar = '-', string $progressChar = '>'): self
+    {
+        $this->barChar = $barChar;
+        $this->emptyBarChar = $emptyBarChar;
+        $this->progressChar = $progressChar;
+        return $this;
+    }
+
+    /**
+     * Setzt die Häufigkeit der Aktualisierung
+     */
+    public function setRedrawFrequency(int $frequency): self
+    {
+        $this->redrawFrequency = max(1, $frequency);
+        return $this;
+    }
+
+    /**
+     * Erhöht den Fortschritt um den angegebenen Schritt
+     */
+    public function advance(int $step = 1): self
+    {
+        $this->setCurrent($this->current + $step);
+        return $this;
+    }
+
+    /**
+     * Setzt den aktuellen Fortschritt
+     */
+    public function setCurrent(int $current): self
+    {
+        $this->current = min($this->total, max(0, $current));
+
+        $this->writeCount++;
+        if ($this->writeCount >= $this->redrawFrequency || $this->firstRun || $this->current >= $this->total) {
+            $this->display();
+            $this->writeCount = 0;
+        }
+
+        return $this;
+    }
+
+    /**
+     * Startet die Fortschrittsanzeige
+     */
+    public function start(): self
+    {
+        $this->startTime = microtime(true);
+        $this->current = 0;
+        $this->firstRun = true;
+        $this->display();
+        return $this;
+    }
+
+    /**
+     * Beendet die Fortschrittsanzeige
+     */
+    public function finish(): self
+    {
+        if ($this->current < $this->total) {
+            $this->current = $this->total;
+        }
+
+        $this->display();
+        $this->output->newLine(2);
+
+        return $this;
+    }
+
+    /**
+     * Zeigt die Fortschrittsanzeige an
+     */
+    private function display(): void
+    {
+        if (!$this->firstRun) {
+            // Bewege den Cursor eine Zeile nach oben
+            $this->output->write("\033[1A");
+            // Lösche die aktuelle Zeile
+            $this->output->write("\033[2K");
+        }
+
+        $this->firstRun = false;
+
+        $percent = $this->current / $this->total;
+        $bar = $this->getProgressBar($percent);
+
+        $replacements = [
+            '%bar%' => $bar,
+            '%current%' => (string) $this->current,
+            '%total%' => (string) $this->total,
+            '%percent%' => number_format($percent * 100, 0),
+            '%elapsed%' => $this->getElapsedTime(),
+            '%remaining%' => $this->getRemaining($percent),
+        ];
+
+        $line = str_replace(array_keys($replacements), array_values($replacements), $this->format);
+
+        $this->output->writeLine($line);
+    }
+
+    /**
+     * Generiert die Fortschrittsanzeige
+     */
+    private function getProgressBar(float $percent): string
+    {
+        $completedWidth = (int) floor($percent * $this->width);
+        $emptyWidth = $this->width - $completedWidth - ($completedWidth < $this->width ? 1 : 0);
+
+        $bar = str_repeat($this->barChar, $completedWidth);
+        if ($completedWidth < $this->width) {
+            $bar .= $this->progressChar . str_repeat($this->emptyBarChar, $emptyWidth);
+        }
+
+        return $bar;
+    }
+
+    /**
+     * Berechnet die verstrichene Zeit
+     */
+    private function getElapsedTime(): string
+    {
+        return number_format(microtime(true) - $this->startTime, 1);
+    }
+
+    /**
+     * Berechnet die verbleibende Zeit
+     */
+    private function getRemaining(float $percent): string
+    {
+        if ($percent === 0) {
+            return '--';
+        }
+
+        $elapsed = microtime(true) - $this->startTime;
+        $remaining = $elapsed / $percent - $elapsed;
+
+        return number_format($remaining, 1);
+    }
+}
diff --git a/src/Framework/Console/README.md b/src/Framework/Console/README.md
new file mode 100644
index 00000000..4d965e5b
--- /dev/null
+++ b/src/Framework/Console/README.md
@@ -0,0 +1,106 @@
+# Console-Modul
+
+Dieses Modul bietet eine flexible und benutzerfreundliche Konsolen-Schnittstelle für Ihre PHP-Anwendung. Es ermöglicht die Erstellung von CLI-Befehlen mit einfacher Eingabe- und Ausgabehandlung.
+
+## Hauptkomponenten
+
+### ConsoleApplication
+
+Die zentrale Klasse zur Verwaltung und Ausführung von Konsolen-Befehlen.
+
+```php
+$app = new ConsoleApplication('app', 'Meine Anwendung');
+$app->registerCommands(new MyCommands());
+$app->run($argv);
+```
+
+### ConsoleCommand-Attribut
+
+Verwenden Sie das `ConsoleCommand`-Attribut, um Methoden als Konsolenbefehle zu kennzeichnen:
+
+```php
+class MyCommands
+{
+    #[ConsoleCommand(name: 'hello', description: 'Gibt eine Begrüßung aus')]
+    public function sayHello(ConsoleInput $input, ConsoleOutput $output): int
+    {
+        $name = $input->getArgument(0, 'Welt');
+        $output->writeLine("Hallo, {$name}!", ConsoleColor::BRIGHT_GREEN);
+        return 0;
+    }
+}
+```
+
+### ConsoleInput und ConsoleOutput
+
+Diese Klassen bieten Methoden für die Ein- und Ausgabe in der Konsole:
+
+```php
+// Eingabe
+$name = $input->ask('Wie heißen Sie?');
+$confirm = $input->confirm('Fortfahren?', true);
+$option = $input->getOption('verbose');
+
+// Ausgabe
+$output->writeSuccess('Operation erfolgreich!');
+$output->writeError('Fehler aufgetreten!');
+$output->writeInfo('Wussten Sie schon...');
+```
+
+## Fortschrittsanzeigen
+
+### ProgressBar
+
+Zeigt eine Fortschrittsanzeige für Operationen mit bekannter Länge:
+
+```php
+$total = count($items);
+$progress = new ProgressBar($output, $total);
+$progress->start();
+
+foreach ($items as $item) {
+    // Verarbeite $item
+    $progress->advance();
+}
+
+$progress->finish();
+```
+
+### Spinner
+
+Zeigt einen animierten Spinner für Operationen unbekannter Länge:
+
+```php
+$spinner = new Spinner($output, 'Lade Daten...');
+$spinner->start();
+
+// Ausführung der Operation
+do {
+    // Arbeit ausführen
+    $spinner->update();
+} while (!$finished);
+
+$spinner->success('Daten erfolgreich geladen!');
+```
+
+## Beispiele
+
+Sehen Sie sich die Beispielklassen im `Examples`-Verzeichnis an, um mehr über die Verwendung der Komponenten zu erfahren:
+
+- `ProgressBarExample`: Zeigt verschiedene Konfigurationen der Fortschrittsanzeige
+- `SpinnerExample`: Demonstriert die Verwendung von Spinnern mit verschiedenen Stilen
+
+## Anpassung
+
+Sie können die Anzeige anpassen, indem Sie benutzerdefinierte Formatierungen und Farben verwenden:
+
+```php
+$progress->setFormat('%bar% %percent%%');
+$progress->setBarCharacters('█', '░', '█');
+
+$spinner = new Spinner($output, 'Lade...', SpinnerStyle::BOUNCE);
+```
+
+## Fehlerbehebung
+
+Wenn Probleme mit der Anzeige auftreten, stellen Sie sicher, dass Ihr Terminal ANSI-Escape-Sequenzen unterstützt. Die meisten modernen Terminals tun dies, aber Windows-Terminals können Einschränkungen haben.
diff --git a/src/Framework/Console/Screen/ClearStrategy.php b/src/Framework/Console/Screen/ClearStrategy.php
new file mode 100644
index 00000000..a7f6c427
--- /dev/null
+++ b/src/Framework/Console/Screen/ClearStrategy.php
@@ -0,0 +1,15 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Console\Screen;
+
+/**
+ * Strategien für das Löschen des Bildschirms.
+ */
+enum ClearStrategy
+{
+    case NEVER;           // Niemals löschen
+    case ALWAYS;          // Immer löschen
+    case ON_NEW_SCREEN;   // Nur bei neuen Bildschirmen
+    case SMART;           // Intelligente Entscheidung
+}
diff --git a/src/Framework/Console/Screen/Cursor.php b/src/Framework/Console/Screen/Cursor.php
new file mode 100644
index 00000000..cab602fa
--- /dev/null
+++ b/src/Framework/Console/Screen/Cursor.php
@@ -0,0 +1,127 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Console\Screen;
+
+use App\Framework\Console\ConsoleOutput;
+
+/**
+ * Verantwortlich für Cursor-Positionierung.
+ */
+final class Cursor
+{
+    public function __construct(
+        private ConsoleOutput $output
+    ) {}
+
+    /**
+     * Bewegt den Cursor zu einer bestimmten Position.
+     */
+    public function moveTo(int $row, int $col): self
+    {
+        if ($this->output->isTerminal()) {
+            $this->output->writeRaw(CursorControlCode::POSITION->format($row, $col));
+        }
+        return $this;
+    }
+
+    /**
+     * Bewegt den Cursor zum Anfang (Home-Position).
+     */
+    public function home(): self
+    {
+        if ($this->output->isTerminal()) {
+            // Die Home-Position ist 1,1 (obere linke Ecke)
+            $this->output->writeRaw(CursorControlCode::POSITION->format(1, 1));
+        }
+        return $this;
+    }
+
+    /**
+     * Bewegt den Cursor um X Zeilen nach oben.
+     */
+    public function up(int $lines = 1): self
+    {
+        if ($this->output->isTerminal() && $lines > 0) {
+            $this->output->writeRaw(CursorControlCode::UP->format($lines));
+        }
+        return $this;
+    }
+
+    /**
+     * Bewegt den Cursor um X Zeilen nach unten.
+     */
+    public function down(int $lines = 1): self
+    {
+        if ($this->output->isTerminal() && $lines > 0) {
+            $this->output->writeRaw(CursorControlCode::DOWN->format($lines));
+        }
+        return $this;
+    }
+
+    /**
+     * Bewegt den Cursor um X Spalten nach links.
+     */
+    public function left(int $columns = 1): self
+    {
+        if ($this->output->isTerminal() && $columns > 0) {
+            $this->output->writeRaw(CursorControlCode::LEFT->format($columns));
+        }
+        return $this;
+    }
+
+    /**
+     * Bewegt den Cursor um X Spalten nach rechts.
+     */
+    public function right(int $columns = 1): self
+    {
+        if ($this->output->isTerminal() && $columns > 0) {
+            $this->output->writeRaw(CursorControlCode::RIGHT->format($columns));
+        }
+        return $this;
+    }
+
+    /**
+     * Versteckt den Cursor.
+     */
+    public function hide(): self
+    {
+        if ($this->output->isTerminal()) {
+            $this->output->writeRaw(CursorControlCode::HIDE->format());
+        }
+        return $this;
+    }
+
+    /**
+     * Zeigt den Cursor wieder an.
+     */
+    public function show(): self
+    {
+        if ($this->output->isTerminal()) {
+            $this->output->writeRaw(CursorControlCode::SHOW->format());
+        }
+        return $this;
+    }
+
+    /**
+     * Speichert die aktuelle Cursorposition.
+     */
+    public function save(): self
+    {
+        if ($this->output->isTerminal()) {
+            $this->output->writeRaw(CursorControlCode::SAVE->format());
+        }
+        return $this;
+    }
+
+    /**
+     * Stellt die zuvor gespeicherte Cursorposition wieder her.
+     */
+    public function restore(): self
+    {
+        if ($this->output->isTerminal()) {
+            $this->output->writeRaw(CursorControlCode::RESTORE->format());
+        }
+        return $this;
+    }
+}
diff --git a/src/Framework/Console/Screen/CursorControlCode.php b/src/Framework/Console/Screen/CursorControlCode.php
new file mode 100644
index 00000000..dded3131
--- /dev/null
+++ b/src/Framework/Console/Screen/CursorControlCode.php
@@ -0,0 +1,48 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Console\Screen;
+
+/**
+ * Cursor-Steuerungscodes nach ANSI-Standard.
+ */
+enum CursorControlCode: string
+{
+    // Bewegung
+    case UP = "A";           // n Zeilen nach oben
+    case DOWN = "B";         // n Zeilen nach unten
+    case RIGHT = "C";        // n Spalten nach rechts
+    case LEFT = "D";         // n Spalten nach links
+    case NEXT_LINE = "E";    // n Zeilen nach unten und an den Anfang
+    case PREV_LINE = "F";    // n Zeilen nach oben und an den Anfang
+    case COLUMN = "G";       // Zur absoluten Spalte
+    case POSITION = "H";     // Zur Position (Zeile;Spalte)
+
+    // Sichtbarkeit
+    case HIDE = "?25l";      // Cursor verstecken
+    case SHOW = "?25h";      // Cursor anzeigen
+
+    // Andere
+    case SAVE = "s";         // Cursorposition speichern
+    case RESTORE = "u";      // Cursorposition wiederherstellen
+
+    /**
+     * Formatiert den ANSI-Steuerungscode korrekt.
+     */
+    public function format(int ...$params): string
+    {
+        // Wenn keine Parameter gegeben sind, aber wir einen speziellen Escape-Code haben
+        if (empty($params) && in_array($this, [self::HIDE, self::SHOW])) {
+            return "\033[{$this->value}";
+        }
+
+        // Wenn keine Parameter, dann ohne formatieren
+        if (empty($params)) {
+            return "\033[{$this->value}";
+        }
+
+        // Wenn Parameter vorhanden sind, formatieren
+        $paramStr = implode(';', $params);
+        return "\033[{$paramStr}{$this->value}";
+    }
+}
diff --git a/src/Framework/Console/Screen/Display.php b/src/Framework/Console/Screen/Display.php
new file mode 100644
index 00000000..848cd033
--- /dev/null
+++ b/src/Framework/Console/Screen/Display.php
@@ -0,0 +1,107 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Console\Screen;
+
+use App\Framework\Console\ConsoleOutput;
+
+/**
+ * Verantwortlich für Bildschirm-Management (Löschen, etc.)
+ */
+final readonly class Display
+{
+    public function __construct(
+        private ConsoleOutput $output
+    ) {}
+
+    /**
+     * Löscht den gesamten Bildschirm und setzt den Cursor an den Anfang.
+     */
+    public function clear(): self
+    {
+        if ($this->output->isTerminal()) {
+            // Bildschirm löschen und Cursor an den Anfang setzen
+            $this->output->writeRaw(ScreenControlCode::CLEAR_ALL->format());
+            $this->output->writeRaw(CursorControlCode::POSITION->format(1, 1));
+        }
+        return $this;
+    }
+
+    /**
+     * Löscht die aktuelle Zeile.
+     */
+    public function clearLine(): self
+    {
+        if ($this->output->isTerminal()) {
+            $this->output->writeRaw(ScreenControlCode::CLEAR_LINE->format());
+            $this->output->writeRaw("\r"); // Cursor an den Zeilenanfang
+        }
+        return $this;
+    }
+
+    /**
+     * Löscht vom Cursor bis zum Ende des Bildschirms.
+     */
+    public function clearToEnd(): self
+    {
+        if ($this->output->isTerminal()) {
+            $this->output->writeRaw(ScreenControlCode::CLEAR_BELOW->format());
+        }
+        return $this;
+    }
+
+    /**
+     * Löscht vom Cursor bis zum Anfang des Bildschirms.
+     */
+    public function clearToBeginning(): self
+    {
+        if ($this->output->isTerminal()) {
+            $this->output->writeRaw(ScreenControlCode::CLEAR_ABOVE->format());
+        }
+        return $this;
+    }
+
+    /**
+     * Löscht vom Cursor bis zum Ende der Zeile.
+     */
+    public function clearLineToEnd(): self
+    {
+        if ($this->output->isTerminal()) {
+            $this->output->writeRaw(ScreenControlCode::CLEAR_LINE_RIGHT->format());
+        }
+        return $this;
+    }
+
+    /**
+     * Löscht vom Cursor bis zum Anfang der Zeile.
+     */
+    public function clearLineToBeginning(): self
+    {
+        if ($this->output->isTerminal()) {
+            $this->output->writeRaw(ScreenControlCode::CLEAR_LINE_LEFT->format());
+        }
+        return $this;
+    }
+
+    /**
+     * Aktiviert den alternativen Buffer (für Vollbild-Anwendungen).
+     */
+    public function useAlternateBuffer(): self
+    {
+        if ($this->output->isTerminal()) {
+            $this->output->writeRaw(ScreenControlCode::ALTERNATE_BUFFER->format());
+        }
+        return $this;
+    }
+
+    /**
+     * Kehrt zum Hauptbuffer zurück.
+     */
+    public function useMainBuffer(): self
+    {
+        if ($this->output->isTerminal()) {
+            $this->output->writeRaw(ScreenControlCode::MAIN_BUFFER->format());
+        }
+        return $this;
+    }
+}
diff --git a/src/Framework/Console/Screen/ScreenControlCode.php b/src/Framework/Console/Screen/ScreenControlCode.php
new file mode 100644
index 00000000..f438afbb
--- /dev/null
+++ b/src/Framework/Console/Screen/ScreenControlCode.php
@@ -0,0 +1,38 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Console\Screen;
+
+/**
+ * Bildschirm-Steuerungscodes nach ANSI-Standard.
+ */
+enum ScreenControlCode: string
+{
+    case CLEAR_ALL = "2J";         // Gesamten Bildschirm löschen
+    case CLEAR_ABOVE = "1J";        // Bildschirm vom Cursor nach oben löschen
+    case CLEAR_BELOW = "0J";        // Bildschirm vom Cursor nach unten löschen
+    case CLEAR_LINE = "2K";         // Komplette Zeile löschen
+    case CLEAR_LINE_LEFT = "1K";    // Zeile vom Cursor nach links löschen
+    case CLEAR_LINE_RIGHT = "0K";   // Zeile vom Cursor nach rechts löschen
+    case SCROLL_UP = "S";           // Bildschirm nach oben scrollen
+    case SCROLL_DOWN = "T";         // Bildschirm nach unten scrollen
+    case SAVE_SCREEN = "?47h";      // Bildschirm speichern
+    case RESTORE_SCREEN = "?47l";   // Bildschirm wiederherstellen
+    case ALTERNATE_BUFFER = "?1049h"; // Alternativen Puffer aktivieren
+    case MAIN_BUFFER = "?1049l";    // Hauptpuffer wiederherstellen
+
+    /**
+     * Formatiert den ANSI-Steuerungscode korrekt.
+     */
+    public function format(int ...$params): string
+    {
+        // Wenn keine Parameter, dann ohne formatieren
+        if (empty($params)) {
+            return "\033[{$this->value}";
+        }
+
+        // Wenn Parameter vorhanden sind, formatieren
+        $paramStr = implode(';', $params);
+        return "\033[{$paramStr}{$this->value}";
+    }
+}
diff --git a/src/Framework/Console/Screen/ScreenManager.php b/src/Framework/Console/Screen/ScreenManager.php
new file mode 100644
index 00000000..2a45b9c0
--- /dev/null
+++ b/src/Framework/Console/Screen/ScreenManager.php
@@ -0,0 +1,145 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Console\Screen;
+
+use App\Framework\Console\ConsoleOutput;
+
+/**
+ * Verwaltet intelligentes Bildschirm-Management.
+ */
+final class ScreenManager
+{
+    private ClearStrategy $strategy = ClearStrategy::SMART;
+    private bool $interactiveMode = false;
+    private ?ScreenType $lastScreenType = null;
+    private int $screenCount = 0;
+
+    public function __construct(
+        private ConsoleOutput $output
+    ) {}
+
+    /**
+     * Setzt die Löschstrategie.
+     */
+    public function setStrategy(ClearStrategy $strategy): self
+    {
+        $this->strategy = $strategy;
+        return $this;
+    }
+
+    /**
+     * Aktiviert/deaktiviert den interaktiven Modus.
+     */
+    public function setInteractiveMode(bool $interactive = true): self
+    {
+        $this->interactiveMode = $interactive;
+        return $this;
+    }
+
+    /**
+     * Markiert den Beginn eines neuen Bildschirms.
+     * Diese Methode rufst du VOR der Ausgabe auf.
+     */
+    public function newScreen(ScreenType $type = ScreenType::CONTENT): self
+    {
+        if ($this->shouldClear($type)) {
+            $this->output->display()->clear();
+        }
+
+        $this->lastScreenType = $type;
+        $this->screenCount++;
+
+        return $this;
+    }
+
+    /**
+     * Convenience-Methoden für häufige Screen-Typen.
+     */
+    public function newMenu(): self
+    {
+        return $this->newScreen(ScreenType::MENU);
+    }
+
+    public function newDialog(): self
+    {
+        return $this->newScreen(ScreenType::DIALOG);
+    }
+
+    public function newContent(): self
+    {
+        return $this->newScreen(ScreenType::CONTENT);
+    }
+
+    public function newLog(): self
+    {
+        return $this->newScreen(ScreenType::LOG);
+    }
+
+    public function newProgress(): self
+    {
+        return $this->newScreen(ScreenType::PROGRESS);
+    }
+
+    /**
+     * Zeigt eine temporäre Nachricht für eine bestimmte Zeit an.
+     */
+    public function temporary(string $message, int $seconds = 2): self
+    {
+        $this->output->writeLine($message);
+        sleep($seconds);
+        $this->output->display()->clearLine();
+        return $this;
+    }
+
+    /**
+     * Wartet auf Benutzereingabe.
+     */
+    public function waitForInput(): self
+    {
+        if ($this->output->isTerminal()) {
+            fread(STDIN, 1);
+        }
+        return $this;
+    }
+
+    /**
+     * Entscheidet, ob der Bildschirm gelöscht werden soll.
+     */
+    private function shouldClear(ScreenType $type): bool
+    {
+        if (!$this->output->isTerminal()) {
+            return false;
+        }
+
+        return match($this->strategy) {
+            ClearStrategy::NEVER => false,
+            ClearStrategy::ALWAYS => true,
+            ClearStrategy::ON_NEW_SCREEN => $type === ScreenType::MENU || $type === ScreenType::DIALOG,
+            ClearStrategy::SMART => $this->shouldClearSmart($type),
+        };
+    }
+
+    /**
+     * Intelligente Entscheidung für das Löschen.
+     */
+    private function shouldClearSmart(ScreenType $type): bool
+    {
+        // Nie löschen für Logs und Progress
+        if ($type === ScreenType::LOG || $type === ScreenType::PROGRESS) {
+            return false;
+        }
+
+        // Immer löschen für Menüs und Dialoge im interaktiven Modus
+        if ($this->interactiveMode && ($type === ScreenType::MENU || $type === ScreenType::DIALOG)) {
+            return true;
+        }
+
+        // Für Content: nur löschen wenn der letzte Screen ein anderer Typ war
+        if ($type === ScreenType::CONTENT) {
+            return $this->lastScreenType !== null && $this->lastScreenType !== ScreenType::CONTENT;
+        }
+
+        return false;
+    }
+}
diff --git a/src/Framework/Console/Screen/ScreenType.php b/src/Framework/Console/Screen/ScreenType.php
new file mode 100644
index 00000000..ce321156
--- /dev/null
+++ b/src/Framework/Console/Screen/ScreenType.php
@@ -0,0 +1,17 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Console\Screen;
+
+/**
+ * Typen von Bildschirminhalten.
+ */
+enum ScreenType
+{
+    case MENU;      // Menüs und Navigation
+    case DIALOG;    // Dialoge und Formulare
+    case CONTENT;   // Normale Inhaltsanzeige
+    case LOG;       // Log-Ausgaben
+    case PROGRESS;  // Fortschrittsanzeigen
+    case INFO;      // Informationsmeldungen
+}
diff --git a/src/Framework/Console/Spinner.php b/src/Framework/Console/Spinner.php
new file mode 100644
index 00000000..1202786e
--- /dev/null
+++ b/src/Framework/Console/Spinner.php
@@ -0,0 +1,119 @@
+<?php
+
+namespace App\Framework\Console;
+
+class Spinner
+{
+    private ConsoleOutputInterface $output;
+    private string $message;
+    private array $frames;
+    private int $currentFrame = 0;
+    private float $startTime;
+    private bool $active = false;
+    private float $interval;
+    private int $updateCount = 0;
+
+    public function __construct(
+        ConsoleOutputInterface $output,
+        string $message = 'Loading...',
+        SpinnerStyle $style = SpinnerStyle::DOTS,
+        float $interval = 0.1
+    ) {
+        $this->output = $output;
+        $this->message = $message;
+        $this->frames = $style->getFrames();
+        $this->interval = $interval;
+    }
+
+    /**
+     * Startet den Spinner
+     */
+    public function start(): self
+    {
+        $this->startTime = microtime(true);
+        $this->active = true;
+        $this->update();
+        return $this;
+    }
+
+    /**
+     * Stoppt den Spinner mit einer Erfolgs-, Fehler- oder neutralen Nachricht
+     */
+    public function stop(?string $message = null, ?ConsoleColor $color = null): self
+    {
+        $this->active = false;
+
+        // Lösche die aktuelle Zeile
+        $this->output->write("\r\033[2K");
+
+        if ($message !== null) {
+            $this->output->writeLine($message, $color);
+        }
+
+        return $this;
+    }
+
+    /**
+     * Stoppt den Spinner mit einer Erfolgsmeldung
+     */
+    public function success(string $message): self
+    {
+        return $this->stop("✓ " . $message, ConsoleColor::BRIGHT_GREEN);
+    }
+
+    /**
+     * Stoppt den Spinner mit einer Fehlermeldung
+     */
+    public function error(string $message): self
+    {
+        return $this->stop("✗ " . $message, ConsoleColor::BRIGHT_RED);
+    }
+
+    /**
+     * Ändert die Nachricht des Spinners während er läuft
+     */
+    public function setMessage(string $message): self
+    {
+        $this->message = $message;
+        if ($this->active) {
+            $this->update();
+        }
+        return $this;
+    }
+
+    /**
+     * Aktualisiert die Anzeige des Spinners
+     */
+    public function update(): self
+    {
+        if (!$this->active) {
+            return $this;
+        }
+
+        $this->updateCount++;
+
+        // Aktualisiere nur in festgelegten Intervallen
+        $elapsed = microtime(true) - $this->startTime;
+        $expectedUpdates = floor($elapsed / $this->interval);
+
+        if ($this->updateCount < $expectedUpdates) {
+            $this->currentFrame = ($this->currentFrame + 1) % count($this->frames);
+
+            // Lösche die aktuelle Zeile und schreibe den aktualisierten Spinner
+            $frame = $this->frames[$this->currentFrame];
+            $this->output->write("\r\033[2K{$frame} {$this->message}");
+
+            $this->updateCount = $expectedUpdates;
+        }
+
+        return $this;
+    }
+
+    /**
+     * Beendet den Spinner ohne Ausgabe
+     */
+    public function clear(): self
+    {
+        return $this->stop();
+    }
+}
diff --git a/src/Framework/Console/SpinnerStyle.php b/src/Framework/Console/SpinnerStyle.php
new file mode 100644
index 00000000..d030f5d2
--- /dev/null
+++ b/src/Framework/Console/SpinnerStyle.php
@@ -0,0 +1,24 @@
+<?php
+
+namespace App\Framework\Console;
+
+enum SpinnerStyle: string
+{
+    case DOTS = 'dots';
+    case LINE = 'line';
+    case BOUNCE = 'bounce';
+    case ARROW = 'arrow';
+
+    /**
+     * Gibt die Frames für den gewählten Stil zurück
+     */
+    public function getFrames(): array
+    {
+        return match($this) {
+            self::DOTS => ['.  ', '.. ', '...', ' ..', '  .', '   '],
+            self::LINE => ['|', '/', '-', '\\'],
+            self::BOUNCE => ['⠈', '⠐', '⠠', '⢀', '⡀', '⠄', '⠂', '⠁'],
+            self::ARROW => ['←', '↖', '↑', '↗', '→', '↘', '↓', '↙']
+        };
+    }
+}
diff --git a/src/Framework/Context/ContextType.php b/src/Framework/Context/ContextType.php
new file mode 100644
index 00000000..3e079c1d
--- /dev/null
+++ b/src/Framework/Context/ContextType.php
@@ -0,0 +1,13 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Context;
+
+enum ContextType: string
+{
+    case WEB = 'web';
+    case CONSOLE = 'console';
+    case WORKER = 'worker';
+    case CLI_SCRIPT = 'cli-script';
+    case TEST = 'test';
+}
diff --git a/src/Framework/Context/ExecutionContext.php b/src/Framework/Context/ExecutionContext.php
new file mode 100644
index 00000000..8b6ab641
--- /dev/null
+++ b/src/Framework/Context/ExecutionContext.php
@@ -0,0 +1,109 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Context;
+
+final readonly class ExecutionContext
+{
+    public function __construct(
+        private ContextType $type,
+        private array $metadata = []
+    ) {}
+
+    public function getType(): ContextType
+    {
+        return $this->type;
+    }
+
+    public function isWeb(): bool
+    {
+        return $this->type === ContextType::WEB;
+    }
+
+    public function isWorker(): bool
+    {
+        return $this->type === ContextType::WORKER;
+    }
+
+    public function isConsole(): bool
+    {
+        return $this->type === ContextType::CONSOLE;
+    }
+
+    public function isCli(): bool
+    {
+        return in_array($this->type, [
+            ContextType::CONSOLE,
+            ContextType::WORKER,
+            ContextType::CLI_SCRIPT
+        ]);
+    }
+
+    public function isTest(): bool
+    {
+        return $this->type === ContextType::TEST;
+    }
+
+    public function getMetadata(): array
+    {
+        return array_merge([
+            'type' => $this->type->value,
+            'sapi' => php_sapi_name(),
+            'script' => $_SERVER['argv'][0] ?? null,
+            'command_line' => implode(' ', $_SERVER['argv'] ?? []),
+            'pid' => getmypid(),
+        ], $this->metadata);
+    }
+
+    public static function detect(): self
+    {
+        // Test Environment
+        if (defined('PHPUNIT_COMPOSER_INSTALL') ||
+            isset($_ENV['APP_ENV']) && $_ENV['APP_ENV'] === 'testing') {
+            return new self(ContextType::TEST, ['detected_by' => 'phpunit_or_env']);
+        }
+
+        // Web Request
+        if (php_sapi_name() !== 'cli') {
+            return new self(ContextType::WEB, ['detected_by' => 'sapi']);
+        }
+
+        // CLI Detection
+        $scriptName = $_SERVER['argv'][0] ?? '';
+        $commandLine = implode(' ', $_SERVER['argv'] ?? []);
+
+        $type = match(true) {
+            str_contains($scriptName, 'worker') => ContextType::WORKER,
+            str_contains($scriptName, 'artisan') => ContextType::CONSOLE,
+            str_contains($commandLine, 'pest') => ContextType::TEST,
+            str_contains($commandLine, 'phpunit') => ContextType::TEST,
+            default => ContextType::CLI_SCRIPT
+        };
+
+        return new self($type, [
+            'detected_by' => 'cli_analysis',
+            'script_name' => $scriptName,
+            'command_line' => $commandLine
+        ]);
+    }
+
+    public static function forWorker(): self
+    {
+        return new self(ContextType::WORKER, ['forced_by' => 'worker']);
+    }
+
+    public static function forTest(): self
+    {
+        return new self(ContextType::TEST, ['forced_by' => 'test']);
+    }
+
+    public static function forConsole(): self
+    {
+        return new self(ContextType::CONSOLE, ['forced_by' => 'console']);
+    }
+
+    public static function forWeb(): self
+    {
+        return new self(ContextType::WEB, ['forced_by' => 'web']);
+    }
+}
diff --git a/src/Framework/Core/AppBootstrapper.php b/src/Framework/Core/AppBootstrapper.php
new file mode 100644
index 00000000..1cac704f
--- /dev/null
+++ b/src/Framework/Core/AppBootstrapper.php
@@ -0,0 +1,133 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Core;
+
+use App\Framework\Cache\Cache;
+use App\Framework\Cache\CacheInitializer;
+use App\Framework\Config\Configuration;
+use App\Framework\Config\Environment;
+use App\Framework\Config\TypedConfigInitializer;
+use App\Framework\Config\TypedConfiguration;
+use App\Framework\Console\ConsoleApplication;
+use App\Framework\Console\ConsoleOutput;
+use App\Framework\Context\ExecutionContext;
+use App\Framework\DI\DefaultContainer;
+use App\Framework\DI\Container;
+use App\Framework\ErrorHandling\ErrorHandler;
+use App\Framework\Http\ResponseEmitter;
+use App\Framework\Performance\PerformanceCategory;
+use App\Framework\Performance\PerformanceMeter;
+
+/**
+ * Verantwortlich für die grundlegende Initialisierung der Anwendung
+ */
+final readonly class AppBootstrapper
+{
+    private DefaultContainer $container;
+
+    private ContainerBootstrapper $bootstrapper;
+
+    public function __construct(
+        private string           $basePath,
+        private PerformanceMeter $meter,
+        private array            $config = [],
+    ){
+        $this->container = new DefaultContainer();
+        $this->bootstrapper = new ContainerBootstrapper($this->container);
+
+
+        $env = Environment::fromFile($this->basePath . '/.env');
+
+        $this->container->instance(TypedConfiguration::class, new TypedConfigInitializer($env)($this->container));
+
+
+        // ExecutionContext detection sollte das erste sein, das nach dem Instanzieren des containers passiert. noch bevor dem bootstrap des containers.
+        $executionContext = ExecutionContext::detect();
+        $this->container->instance(ExecutionContext::class, $executionContext);
+
+        error_log("AppBootstrapper: Context detected as {$executionContext->getType()->value}");
+        error_log('AppBootstrapper: Context metadata: ' . json_encode($executionContext->getMetadata()));
+    }
+
+    public function bootstrapWeb(): Application
+    {
+        $this->bootstrap();
+        $this->registerWebErrorHandler();
+        $this->registerApplication();
+
+        return $this->container->get(Application::class);
+    }
+
+    public function bootstrapConsole(): ConsoleApplication
+    {
+        $this->bootstrap();
+        $this->registerCliErrorHandler();
+        $this->registerConsoleApplication();
+
+        return $this->container->get(ConsoleApplication::class);
+    }
+
+    public function bootstrapWorker(): Container
+    {
+        $this->bootstrap();
+        $this->registerCliErrorHandler();
+
+        $consoleOutput = new ConsoleOutput();
+        $this->container->instance(ConsoleOutput::class, $consoleOutput);
+
+        return $this->container;
+    }
+
+    private function bootstrap(): void
+    {
+        $this->meter->startMeasure('bootstrap:start', PerformanceCategory::SYSTEM);
+
+        $this->bootstrapper->bootstrap($this->basePath, $this->meter, $this->config);
+
+        // ErrorHandler wird jetzt kontextabhängig registriert
+        // $this->container->get(ErrorHandler::class)->register();
+
+        $this->meter->endMeasure('bootstrap:end');
+    }
+
+    private function registerWebErrorHandler(): void
+    {
+        $this->container->get(ErrorHandler::class)->register();
+    }
+
+    private function registerCliErrorHandler(): void
+    {
+        $output = $this->container->has(ConsoleOutput::class)
+            ? $this->container->get(ConsoleOutput::class)
+            : new ConsoleOutput();
+
+        $cliErrorHandler = new \App\Framework\ErrorHandling\CliErrorHandler($output);
+        $cliErrorHandler->register();
+    }
+
+    private function registerApplication(): void
+    {
+        $this->container->singleton(Application::class, function (Container $c) {
+            return new Application(
+                $c,
+                $c->get(PathProvider::class),
+                $c->get(ResponseEmitter::class),
+                $c->get(Configuration::class)
+            );
+        });
+    }
+
+    private function registerConsoleApplication(): void
+    {
+        $this->container->singleton(ConsoleApplication::class, function (Container $c) {
+            return new ConsoleApplication(
+                $c,
+                'console',
+                'My Console App',
+                null,
+            );
+        });
+    }
+}
diff --git a/src/Framework/Core/Application.php b/src/Framework/Core/Application.php
new file mode 100644
index 00000000..9fb5d1de
--- /dev/null
+++ b/src/Framework/Core/Application.php
@@ -0,0 +1,103 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Core;
+
+use App\Framework\Cache\Cache;
+use App\Framework\Config\Configuration;
+use App\Framework\Core\Events\AfterEmitResponse;
+use App\Framework\Core\Events\AfterHandleRequest;
+use App\Framework\Core\Events\ApplicationBooted;
+use App\Framework\Core\Events\BeforeEmitResponse;
+use App\Framework\Core\Events\BeforeHandleRequest;
+use App\Framework\Core\Events\EventCompilerPass;
+use App\Framework\Core\Events\EventDispatcher;
+use App\Framework\Core\Events\OnEvent;
+use App\Framework\DI\DefaultContainer;
+use App\Framework\DI\Container;
+use App\Framework\DI\Initializer;
+use App\Framework\Http\MiddlewareManager;
+use App\Framework\Http\Request;
+use App\Framework\Http\ResponseEmitter;
+use App\Framework\Router\HttpRouter;
+use DateTimeImmutable;
+
+final readonly class Application
+{
+    private MiddlewareManager $middlewareManager;
+    private AttributeDiscoveryService $discoveryService;
+    private EventDispatcher $eventDispatcher;
+
+    public function __construct(
+        private Container       $container,
+        private PathProvider    $pathProvider,
+        private ResponseEmitter $responseEmitter,
+        private Configuration   $config
+    ) {
+        // Middleware-Manager initialisieren
+        $this->middlewareManager = $this->container->get(MiddlewareManager::class);
+
+        $this->eventDispatcher = $container->get(EventDispatcher::class);
+
+        // Discovery-Service initialisieren
+        #$this->discoveryService = new AttributeDiscoveryService($container, $pathProvider, $config);
+    }
+
+    /**
+     * Führt die Anwendung aus
+     */
+    public function run(): void
+    {
+        // ApplicationBooted-Event dispatchen
+        $environment = $this->config->get('environment', 'dev');
+        $version = $this->config->get('app.version', 'dev');
+
+
+        $bootEvent = new ApplicationBooted(
+            new DateTimeImmutable(),
+            $environment,
+            $version
+        );
+
+        $this->event($bootEvent);
+
+        // Attribute verarbeiten und Komponenten einrichten
+        #$this->setupApplicationComponents();
+
+        // Sicherstellen, dass ein Router registriert wurde
+        if (!$this->container->has(HttpRouter::class)) {
+            throw new \RuntimeException('Kritischer Fehler: Router wurde nicht initialisiert');
+        }
+
+        $this->event(new BeforeHandleRequest);
+
+
+        $this->event(new AfterHandleRequest);
+
+        $request = $this->container->get(Request::class);
+
+        $response = $this->middlewareManager->chain->handle($request);
+
+        $this->event(new BeforeEmitResponse);
+
+        // Response ausgeben
+        $this->responseEmitter->emit($response);
+
+        $this->event(new AfterEmitResponse);
+    }
+
+    private function event(object $event): void
+    {
+        $this->eventDispatcher->dispatch($event);
+    }
+
+
+    /**
+     * Gibt einen Konfigurationswert zurück
+     */
+    public function config(string $key, mixed $default = null): mixed
+    {
+        return $this->config->get($key, $default);
+    }
+}
diff --git a/src/Framework/Core/AttributeCompiler.php b/src/Framework/Core/AttributeCompiler.php
new file mode 100644
index 00000000..d87ba01c
--- /dev/null
+++ b/src/Framework/Core/AttributeCompiler.php
@@ -0,0 +1,16 @@
+<?php
+
+namespace App\Framework\Core;
+
+interface AttributeCompiler
+{
+    /**
+     * Gibt die Attributklasse zurück, für die dieser Compiler zuständig ist
+     */
+    public function getAttributeClass(): string;
+
+    /**
+     * Kompiliert die gemappten Attributdaten in eine optimierte Form
+     */
+    public function compile(array $data): mixed;
+}
diff --git a/src/Framework/Core/AttributeDiscoveryService.php b/src/Framework/Core/AttributeDiscoveryService.php
new file mode 100644
index 00000000..be5fb5e9
--- /dev/null
+++ b/src/Framework/Core/AttributeDiscoveryService.php
@@ -0,0 +1,101 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Core;
+
+use App\Framework\Auth\AuthMapper;
+use App\Framework\CommandBus\CommandHandlerCompiler;
+use App\Framework\CommandBus\CommandHandlerMapper;
+use App\Framework\Config\Configuration;
+use App\Framework\Console\ConsoleCommandMapper;
+use App\Framework\DI\AttributeProcessorRegistry;
+use App\Framework\DI\DefaultContainer;
+use App\Framework\DI\InitializerMapper;
+use App\Framework\QueryBus\QueryHandlerCompiler;
+use App\Framework\QueryBus\QueryHandlerMapper;
+use Archive\Async1\DiscoveryFactory;
+
+/**
+ * Verwaltet die Entdeckung und Verarbeitung von Attributen
+ */
+readonly class AttributeDiscoveryService
+{
+    public function __construct(
+        private DefaultContainer $container,
+        private PathProvider     $pathProvider,
+        private Configuration    $config
+    ) {}
+
+    /**
+     * Führt die Attribut-Discovery durch und verarbeitet die gefundenen Attribute
+     */
+    public function discoverAndProcess(): array
+    {
+        $useAsyncDiscovery = $this->config->get('async_discovery', true);
+        $srcDir = $this->pathProvider->getSourcePath();
+
+        // Discovery erstellen
+        $discoveryFactory = new DiscoveryFactory();
+        $discovery = $discoveryFactory->create($useAsyncDiscovery, $srcDir);
+
+        // Attribute-Processor-Registry initialisieren
+        $processorRegistry = $this->createProcessorRegistry();
+
+        // Attribute entdecken
+        $results = $discovery->discover($srcDir);
+
+        // Alle Attribute verarbeiten
+        return $processorRegistry->processAll($results);
+    }
+
+    /**
+     * Erstellt und konfiguriert die AttributeProcessorRegistry
+     */
+    private function createProcessorRegistry(): AttributeProcessorRegistry
+    {
+        $processorRegistry = new AttributeProcessorRegistry($this->container);
+
+        // Mapper registrieren
+        $this->registerMappers($processorRegistry);
+
+        // Compiler registrieren
+        $this->registerCompilers($processorRegistry);
+
+        return $processorRegistry;
+    }
+
+    /**
+     * Registriert alle AttributeMapper
+     */
+    private function registerMappers(AttributeProcessorRegistry $registry): void
+    {
+        $registry
+            ->registerMapper(RouteMapper::class)
+            ->registerMapper(CommandHandlerMapper::class)
+            ->registerMapper(\App\Framework\Core\Events\EventHandlerMapper::class)
+            ->registerMapper(\App\Framework\EventBus\EventHandlerMapper::class)
+            ->registerMapper(QueryHandlerMapper::class)
+            ->registerMapper(ConsoleCommandMapper::class)
+            ->registerMapper(AuthMapper::class)
+
+            ->registerMapper(InitializerMapper::class);
+
+        // Hier können weitere Mapper registriert werden
+    }
+
+    /**
+     * Registriert alle AttributeCompiler
+     */
+    private function registerCompilers(AttributeProcessorRegistry $registry): void
+    {
+        $registry
+            ->registerCompiler(RouteCompiler::class)
+            ->registerCompiler(CommandHandlerCompiler::class)
+            ->registerCompiler(\App\Framework\Core\Events\EventHandlerCompiler::class)
+            ->registerCompiler(\App\Framework\EventBus\EventHandlerCompiler::class)
+            ->registerCompiler(QueryHandlerCompiler::class);
+
+        // Hier können weitere Compiler registriert werden
+    }
+}
diff --git a/src/Framework/Core/AttributeMapper.php b/src/Framework/Core/AttributeMapper.php
index 0e499102..14807b95 100644
--- a/src/Framework/Core/AttributeMapper.php
+++ b/src/Framework/Core/AttributeMapper.php
@@ -1,11 +1,16 @@
 <?php
-
 declare(strict_types=1);
 
 namespace App\Framework\Core;
 
+/**
+ * Interface für AttributeMapper mit optimierter Performance
+ */
 interface AttributeMapper
 {
+    /**
+     * Gibt die Attributklasse zurück, die dieser Mapper verarbeiten kann
+     */
     public function getAttributeClass(): string;
 
     /**
@@ -14,4 +19,15 @@ interface AttributeMapper
      * @return array|null
      */
     public function map(object $reflectionTarget, object $attributeInstance): ?array;
+
+    /**
+     * Prüft, ob dieses Attribut auf dem Reflector verarbeitet werden kann
+     * (Schnelle Prüfung ohne vollständige Verarbeitung)
+     */
+    #public function canProcess(\Reflector $reflector): bool;
+
+    /**
+     * Gibt Metadaten über das Attribut zurück (für Debugging und Caching)
+     */
+    #public function getAttributeMetadata(): array;
 }
diff --git a/src/Framework/Core/AttributeMapperLocator.php b/src/Framework/Core/AttributeMapperLocator.php
new file mode 100644
index 00000000..1aef4d2a
--- /dev/null
+++ b/src/Framework/Core/AttributeMapperLocator.php
@@ -0,0 +1,31 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Core;
+
+use RecursiveDirectoryIterator;
+use RecursiveIteratorIterator;
+use ReflectionClass;
+
+final readonly class AttributeMapperLocator
+{
+    private InterfaceImplementationLocator $locator;
+
+    public function __construct()
+    {
+        $this->locator = new InterfaceImplementationLocator();
+    }
+
+    /**
+     * Findet alle Klassen, die das AttributeMapper-Interface implementieren
+     *
+     * @param string $directory Das Basisverzeichnis, in dem gesucht werden soll
+     * @return AttributeMapper[] Array von AttributeMapper-Instanzen
+     */
+    public function locateMappers(string $directory): array
+    {
+        /** @var AttributeMapper[] $mappers */
+        $mappers = $this->locator->locate($directory, AttributeMapper::class);
+        return $mappers;
+    }
+}
diff --git a/src/Framework/Core/AttributeMappingVisitor.php b/src/Framework/Core/AttributeMappingVisitor.php
new file mode 100644
index 00000000..972da2a4
--- /dev/null
+++ b/src/Framework/Core/AttributeMappingVisitor.php
@@ -0,0 +1,270 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Core;
+
+use App\Framework\Cache\Cache;
+use App\Framework\Discovery\FileVisitor;
+
+/**
+ * Visitor zum Verarbeiten von Attributen in Klassen
+ */
+final class AttributeMappingVisitor implements FileVisitor
+{
+    private array $attributeMappers = [];
+    private array $mappedAttributes = [];
+    private array $mapperByClass = [];
+    private array $processingStats = [];
+
+    /**
+     * @param array $attributeMappers Array von AttributeMapper-Instanzen
+     */
+    public function __construct(array $attributeMappers = [])
+    {
+        $this->attributeMappers = $attributeMappers;
+        $this->buildMapperIndex();
+    }
+
+    /**
+     * Erstellt einen Index der Mapper nach Attributklasse für schnelleren Zugriff
+     */
+    private function buildMapperIndex(): void
+    {
+        $this->mapperByClass = [];
+        foreach ($this->attributeMappers as $mapper) {
+            $attributeClass = $mapper->getAttributeClass();
+            $this->mapperByClass[$attributeClass] = $mapper;
+        }
+    }
+
+    public function onScanStart(): void
+    {
+        $this->mappedAttributes = [];
+        $this->processingStats = [
+            'total_classes' => 0,
+            'classes_with_attributes' => 0,
+            'total_attributes' => 0,
+            'processed_attributes' => 0,
+            'skipped_reflectors' => 0
+        ];
+    }
+
+    public function onIncrementalScanStart(): void
+    {
+        // Bei inkrementellem Scan behalten wir die vorhandenen Mappings bei
+        $this->processingStats = [
+            'total_classes' => 0,
+            'classes_with_attributes' => 0,
+            'total_attributes' => 0,
+            'processed_attributes' => 0,
+            'skipped_reflectors' => 0
+        ];
+    }
+
+    public function onIncrementalScanComplete(): void
+    {
+        // Logging der Verarbeitungsstatistiken für inkrementellen Scan
+        error_log("Inkrementelle Attribut-Verarbeitung abgeschlossen: " . json_encode($this->processingStats));
+    }
+
+    public function visitClass(string $className, string $filePath): void
+    {
+        if (!class_exists($className)) {
+            return;
+        }
+
+        $this->processingStats['total_classes']++;
+        $hasAttributes = false;
+
+        try {
+            $reflection = new \ReflectionClass($className);
+
+            // Schnelle Vorprüfung: Hat die Klasse überhaupt relevante Attribute?
+            $relevantAttributes = $this->hasRelevantAttributes($reflection);
+            if (!$relevantAttributes) {
+                return;
+            }
+
+            $hasAttributes = true;
+            $this->processingStats['classes_with_attributes']++;
+
+            // Verarbeite alle Attribute auf Klassenebene
+            $this->processAttributes($reflection->getAttributes(), $reflection);
+
+            // Verarbeite alle Methoden
+            foreach ($reflection->getMethods() as $method) {
+                // Schnelle Vorprüfung für jede Methode
+                if ($this->hasRelevantAttributes($method)) {
+                    $this->processAttributes($method->getAttributes(), $method);
+                }
+            }
+
+            // Verarbeite alle Eigenschaften
+            foreach ($reflection->getProperties() as $property) {
+                // Schnelle Vorprüfung für jede Eigenschaft
+                if ($this->hasRelevantAttributes($property)) {
+                    $this->processAttributes($property->getAttributes(), $property);
+                }
+            }
+        } catch (\Throwable $e) {
+            // Fehler beim Verarbeiten der Klasse protokollieren
+            error_log("Fehler bei der Attributverarbeitung von {$className}: " . $e->getMessage());
+        }
+    }
+
+    /**
+     * Schnelle Vorprüfung, ob ein Reflector relevante Attribute hat
+     */
+    private function hasRelevantAttributes(\Reflector $reflector): bool
+    {
+        if (method_exists($reflector, 'getAttributes')) {
+            $attributes = $reflector->getAttributes();
+            $this->processingStats['total_attributes'] += count($attributes);
+
+            if (empty($attributes)) {
+                return false;
+            }
+
+            foreach ($attributes as $attribute) {
+                $attributeClass = $attribute->getName();
+                if (isset($this->mapperByClass[$attributeClass])) {
+                    $mapper = $this->mapperByClass[$attributeClass];
+                    if ($mapper->canProcess($reflector)) {
+                        return true;
+                    } else {
+                        $this->processingStats['skipped_reflectors']++;
+                    }
+                }
+            }
+        }
+
+        return false;
+    }
+
+    private function processAttributes(array $attributes, \Reflector $reflector): void
+    {
+        foreach ($attributes as $attribute) {
+            $attributeClass = $attribute->getName();
+
+            // Direkter Zugriff auf den Mapper über den Index
+            if (isset($this->mapperByClass[$attributeClass])) {
+                $mapper = $this->mapperByClass[$attributeClass];
+
+                // Zusätzliche Prüfung, ob der Mapper diesen Reflector verarbeiten kann
+                if ($mapper->canProcess($reflector)) {
+                    try {
+                        $attributeInstance = $attribute->newInstance();
+                        $mapper->map($attributeInstance, $reflector);
+                        $this->processingStats['processed_attributes']++;
+
+                        // Speichere für Caching
+                        if (!isset($this->mappedAttributes[$attributeClass])) {
+                            $this->mappedAttributes[$attributeClass] = [];
+                        }
+
+                        // Serialisierbare Repräsentation des Reflectors
+                        $reflectorKey = $this->serializeReflector($reflector);
+
+                        $this->mappedAttributes[$attributeClass][] = [
+                            'attribute' => $attributeInstance,
+                            'reflector' => $reflectorKey,
+                            'metadata' => $mapper->getAttributeMetadata()
+                        ];
+                    } catch (\Throwable $e) {
+                        error_log("Fehler beim Verarbeiten des Attributs {$attributeClass}: " . $e->getMessage());
+                    }
+                }
+            }
+        }
+    }
+
+    /**
+     * Erstellt eine serialisierbare Repräsentation eines Reflectors
+     */
+    private function serializeReflector(\Reflector $reflector): array
+    {
+        if ($reflector instanceof \ReflectionClass) {
+            return [
+                'type' => 'class',
+                'name' => $reflector->getName()
+            ];
+        } elseif ($reflector instanceof \ReflectionMethod) {
+            return [
+                'type' => 'method',
+                'class' => $reflector->getDeclaringClass()->getName(),
+                'name' => $reflector->getName()
+            ];
+        } elseif ($reflector instanceof \ReflectionProperty) {
+            return [
+                'type' => 'property',
+                'class' => $reflector->getDeclaringClass()->getName(),
+                'name' => $reflector->getName()
+            ];
+        }
+
+        return [
+            'type' => 'unknown',
+            'name' => method_exists($reflector, 'getName') ? $reflector->getName() : 'unknown'
+        ];
+    }
+
+    public function onScanComplete(): void
+    {
+        // Logging der Verarbeitungsstatistiken
+        error_log("Attribut-Verarbeitung abgeschlossen: " . json_encode($this->processingStats));
+    }
+
+    public function loadFromCache(Cache $cache): void
+    {
+        $cacheItem = $cache->get($this->getCacheKey());
+        if ($cacheItem->isHit) {
+            $this->mappedAttributes = $cacheItem->value;
+        }
+    }
+
+    public function getCacheKey(): string
+    {
+        return 'attribute_mappings';
+    }
+
+    public function getCacheableData(): mixed
+    {
+        return $this->mappedAttributes;
+    }
+
+    /**
+     * Fügt einen weiteren AttributeMapper hinzu
+     */
+    public function addAttributeMapper(AttributeMapper $mapper): void
+    {
+        $this->attributeMappers[] = $mapper;
+
+        // Aktualisiere den Mapper-Index
+        $attributeClass = $mapper->getAttributeClass();
+        $this->mapperByClass[$attributeClass] = $mapper;
+    }
+
+    /**
+     * Gibt alle Attribute eines bestimmten Typs zurück
+     */
+    public function getAttributesOfType(string $attributeClass): array
+    {
+        return $this->mappedAttributes[$attributeClass] ?? [];
+    }
+
+    /**
+     * Gibt alle gemappten Attribute zurück
+     */
+    public function getAllMappedAttributes(): array
+    {
+        return $this->mappedAttributes;
+    }
+
+    /**
+     * Gibt die Verarbeitungsstatistiken zurück
+     */
+    public function getProcessingStats(): array
+    {
+        return $this->processingStats;
+    }
+}
diff --git a/src/Framework/Core/AttributeProcessor.php b/src/Framework/Core/AttributeProcessor.php
new file mode 100644
index 00000000..0f3008ce
--- /dev/null
+++ b/src/Framework/Core/AttributeProcessor.php
@@ -0,0 +1,85 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Core;
+
+use ReflectionClass;
+use ReflectionMethod;
+
+final readonly class AttributeProcessor
+{
+    /** @var array<string, AttributeMapper> */
+    private array $mapperMap;
+
+    /**
+     * @param AttributeMapper[] $mappers
+     */
+    public function __construct(array $mappers)
+    {
+        $mapperMap = [];
+        foreach ($mappers as $mapper) {
+            $mapperMap[$mapper->getAttributeClass()] = $mapper;
+        }
+        $this->mapperMap = $mapperMap;
+    }
+
+    /**
+     * Verarbeitet alle Attribute einer Klasse
+     */
+    public function processClass(ReflectionClass $refClass, array &$results): void
+    {
+        $this->processAttributes($refClass, $results);
+
+        foreach ($refClass->getMethods(ReflectionMethod::IS_PUBLIC) as $method) {
+            $this->processAttributes($method, $results);
+        }
+    }
+
+    /**
+     * Verarbeitet die Attribute eines Elements (Klasse oder Methode)
+     */
+    private function processAttributes(ReflectionClass|ReflectionMethod $ref, array &$results): void
+    {
+        foreach ($ref->getAttributes() as $attribute) {
+            $attrName = $attribute->getName();
+            if (!isset($this->mapperMap[$attrName])) {
+                continue;
+            }
+
+            $mapped = $this->mapperMap[$attrName]->map($ref, $attribute->newInstance());
+
+            if ($mapped !== null && $ref instanceof ReflectionMethod) {
+                $mapped['parameters'] = $this->extractMethodParameters($ref);
+            }
+
+            if ($mapped !== null) {
+                $results[$attrName][] = $mapped;
+            }
+        }
+    }
+
+    /**
+     * Extrahiert Parameter-Informationen aus einer Methode
+     */
+    private function extractMethodParameters(ReflectionMethod $method): array
+    {
+        $params = [];
+        foreach ($method->getParameters() as $param) {
+            $paramData = [
+                'name' => $param->getName(),
+                'type' => $param->getType()?->getName(),
+                'isBuiltin' => $param->getType()?->isBuiltin() ?? false,
+                'hasDefault' => $param->isDefaultValueAvailable(),
+                'default' => $param->isDefaultValueAvailable() ? $param->getDefaultValue() : null,
+                'attributes' => array_map(
+                    fn ($a) => $a->getName(),
+                    $param->getAttributes()
+                ),
+            ];
+            $params[] = $paramData;
+        }
+
+        return $params;
+    }
+
+}
diff --git a/src/Framework/Core/ClassParser.php b/src/Framework/Core/ClassParser.php
new file mode 100644
index 00000000..7762e14e
--- /dev/null
+++ b/src/Framework/Core/ClassParser.php
@@ -0,0 +1,218 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Core;
+
+/**
+ * Parser für PHP-Klassendateien ohne externe Abhängigkeiten
+ */
+final class ClassParser
+{
+    private static array $classCache = [];
+    private static array $tokenCache = [];
+
+    /**
+     * Gibt alle Klassen, Interfaces und Traits in einer Datei zurück
+     *
+     * @param string $file Pfad zur PHP-Datei
+     * @return array Namen der in der Datei enthaltenen Klassen
+     */
+    public static function getClassesInFile(string $file): array
+    {
+        // Prüfe Cache
+        $cacheKey = md5($file . filemtime($file));
+        if (isset(self::$classCache[$cacheKey])) {
+            return self::$classCache[$cacheKey];
+        }
+
+        $classes = [];
+        $namespace = '';
+        $tokens = self::getTokens($file);
+
+        if ($tokens === null) {
+            return [];
+        }
+
+        $count = count($tokens);
+        $i = 0;
+
+        // Durchlaufe alle Tokens
+        while ($i < $count) {
+            if ($tokens[$i][0] === T_NAMESPACE) {
+                // Namespace finden
+                $namespace = self::parseNamespace($tokens, $i);
+                #debug("Found namespace: '$namespace' in file: $file");
+            } elseif ($tokens[$i][0] === T_CLASS || $tokens[$i][0] === T_INTERFACE || $tokens[$i][0] === T_TRAIT) {
+                // Klasse/Interface/Trait finden
+                $className = self::parseClassName($tokens, $i);
+                if ($className !== null) {
+                    #debug("Found class: '$className', current namespace: '$namespace'");
+
+                    if (empty($namespace)) {
+                        // Fallback: Versuche Namespace aus Dateiinhalt zu extrahieren
+                        $namespace = self::extractNamespaceFromContent($file);
+                        #debug("Fallback namespace from content: '$namespace'");
+                    }
+
+                    if (!empty($namespace)) {
+                        $fullClassName = '\\' . trim($namespace, '\\') . '\\' . $className;
+                    } else {
+                        $fullClassName = '\\' . $className;
+                    }
+
+                    #debug("Final class name: '$fullClassName'");
+                    $classes[] = $fullClassName;
+                }
+            }
+
+            $i++;
+        }
+
+        // Ergebnis cachen
+        self::$classCache[$cacheKey] = $classes;
+
+        #debug($classes);
+
+        return $classes;
+    }
+
+    /**
+     * Parst den Namespace aus den Tokens
+     */
+    private static function parseNamespace(array $tokens, int &$i): string
+    {
+        $namespace = '';
+        $originalI = $i;
+        $i++; // T_NAMESPACE Token überspringen
+
+        #debug("Starting namespace parse at token $i, T_NAMESPACE was at $originalI");
+
+        // Debug: Zeige die nächsten paar Tokens
+        for ($debugI = $i; $debugI < min($i + 10, count($tokens)); $debugI++) {
+            $token = $tokens[$debugI];
+        }
+
+        while ($i < count($tokens)) {
+            $token = $tokens[$i];
+
+            if (is_array($token)) {
+
+                if ($token[0] === T_STRING || $token[0] === T_NS_SEPARATOR || $token[0] === T_NAME_QUALIFIED) {
+                    $namespace .= $token[1];
+                } elseif ($token[0] === T_WHITESPACE) {
+                    // Whitespace ignorieren, aber weitermachen
+                } else {
+                    #debug("Breaking on token: " . token_name($token[0]));
+                    break;
+                }
+            } else {
+                if ($token === ';' || $token === '{') {
+                    break;
+                }
+            }
+
+            $i++;
+        }
+
+        $result = trim($namespace, '\\');
+        #debug("Final parsed namespace: '$result'");
+        return $result;
+    }
+
+    /**
+     * Parst den Klassennamen aus den Tokens
+     */
+    private static function parseClassName(array $tokens, int &$i): ?string
+    {
+        $i += 1; // T_CLASS/T_INTERFACE/T_TRAIT Token überspringen
+
+        // Suche nach dem Namen (nächstes T_STRING Token)
+        while ($i < count($tokens)) {
+            if ($tokens[$i][0] === T_STRING) {
+                return $tokens[$i][1];
+            } elseif ($tokens[$i] === '{' || $tokens[$i] === ';') {
+                // Unerwartetes Ende ohne Klassennamen
+                return null;
+            }
+
+            $i++;
+        }
+
+        return null;
+    }
+
+    /**
+     * Liest Tokens aus einer Datei mit Caching
+     */
+    private static function getTokens(string $file): ?array
+    {
+        if (!file_exists($file)) {
+            return null;
+        }
+
+        $cacheKey = md5($file . filemtime($file));
+        if (isset(self::$tokenCache[$cacheKey])) {
+            return self::$tokenCache[$cacheKey];
+        }
+
+        $code = file_get_contents($file);
+        if ($code === false) {
+            return null;
+        }
+
+        $tokens = token_get_all($code);
+        self::$tokenCache[$cacheKey] = $tokens;
+
+        // Cache-Größe begrenzen
+        if (count(self::$tokenCache) > 100) {
+            // Entferne ältesten Eintrag
+            array_shift(self::$tokenCache);
+        }
+
+        return $tokens;
+    }
+
+    /**
+     * Extrahiert Namespace aus Dateiinhalt als Fallback
+     */
+    private static function extractNamespaceFromContent(string $file): string
+    {
+        $content = file_get_contents($file);
+        if ($content === false) {
+            return '';
+        }
+
+        // Regex für namespace-Deklaration
+        if (preg_match('/namespace\s+([^;]+);/', $content, $matches)) {
+            return trim($matches[1]);
+        }
+
+        return '';
+    }
+
+    /**
+     * Leert den internen Cache
+     */
+    public static function clearCache(): void
+    {
+        self::$classCache = [];
+        self::$tokenCache = [];
+    }
+
+
+    /**
+     * Extrahiert den Klassennamen (mit Namespace) aus einer PHP-Datei
+     */
+    public function getClassNameFromFile(string $file): ?string
+    {
+        $contents = file_get_contents($file);
+        if (
+            preg_match('#namespace\s+([^;]+);#', $contents, $nsMatch)
+            && preg_match('/class\s+(\w+)/', $contents, $classMatch)
+        ) {
+            return trim($nsMatch[1]) . '\\' . trim($classMatch[1]);
+        }
+
+        return null;
+    }
+}
diff --git a/src/Framework/Core/Commands/ClearDiscoveryCache.php b/src/Framework/Core/Commands/ClearDiscoveryCache.php
new file mode 100644
index 00000000..b0ccf7e1
--- /dev/null
+++ b/src/Framework/Core/Commands/ClearDiscoveryCache.php
@@ -0,0 +1,38 @@
+<?php
+
+namespace App\Framework\Core\Commands;
+
+use App\Framework\Cache\Cache;
+use App\Framework\Console\ConsoleCommand;
+use App\Framework\Console\ConsoleInput;
+use App\Framework\Console\ConsoleOutput;
+use App\Framework\Core\PathProvider;
+use App\Framework\Debug\OutputInterface;
+
+final readonly class ClearDiscoveryCache
+{
+    public function __construct(
+        private Cache $cache,
+        private PathProvider $pathProvider)
+    {
+    }
+
+    #[ConsoleCommand('discovery:clear', 'Clears the discovery cache')]
+    public function __invoke(): void
+    {
+        $this->cache->forget('discovery_service');
+    }
+
+    #[ConsoleCommand('clear:routes', 'Clears the routes cache')]
+    public function clearRoutes(ConsoleInput $input, ConsoleOutput $output): void
+    {
+        if(file_exists($this->pathProvider->resolvePath('/cache/routes.cache.php')) === false) {
+            $output->writeError('Routes cache not found');
+            return;
+        }
+
+        unlink($this->pathProvider->resolvePath('/cache/routes.cache.php'));
+
+        $output->writeSuccess('Routes cache cleared');;
+    }
+}
diff --git a/src/Framework/Core/ContainerBootstrapper.php b/src/Framework/Core/ContainerBootstrapper.php
new file mode 100644
index 00000000..17fab072
--- /dev/null
+++ b/src/Framework/Core/ContainerBootstrapper.php
@@ -0,0 +1,104 @@
+<?php
+
+namespace App\Framework\Core;
+
+use App\Framework\Cache\Cache;
+use App\Framework\Cache\CacheInitializer;
+use App\Framework\Config\Configuration;
+use App\Framework\DI\Container;
+use App\Framework\DI\Initializer;
+use App\Framework\Discovery\DiscoveryServiceBootstrapper;
+use App\Framework\Discovery\Results\DiscoveryResults;
+use App\Framework\Http\ResponseEmitter;
+use App\Framework\Performance\PerformanceMeter;
+use App\Framework\Attributes\Route;
+
+final readonly class ContainerBootstrapper
+{
+    public function __construct(
+        private Container $container)
+    {}
+    public function bootstrap(
+        string $basePath,
+        PerformanceMeter $meter,
+        array $config = []): void
+    {
+        // Kern-Dienste im Container registrieren:
+        $this->container->instance(PerformanceMeter::class, $meter);
+        $this->container->instance(Cache::class, new CacheInitializer()());
+        $this->container->instance(Configuration::class, new Configuration($config));
+        $this->container->instance(PathProvider::class, new PathProvider($basePath));
+        $this->container->instance(ResponseEmitter::class, new ResponseEmitter());
+
+        $this->autowire($this->container->get(PathProvider::class), $this->container->get(Configuration::class));
+    }
+
+    private function autowire(PathProvider $pathProvider, Configuration $configuration):void
+    {
+        // Im ContainerBootstrapper
+        $bootstrapper = new DiscoveryServiceBootstrapper($this->container);
+        $results = $bootstrapper->bootstrap();
+
+        // Ergebnisse sind automatisch im Container verfügbar
+        /** @var DiscoveryResults $results */
+        $results = $this->container->get(DiscoveryResults::class);
+
+        #$routeResults = $results->get(Route::class);
+
+
+        // Fallback: Versuche auch mit führendem Backslash
+        /*if (empty($routeResults)) {
+            $routeResults = $results->get('\\' . $routeClass);
+            debug('Tried with leading backslash');
+        }*/
+
+        // Fallback: Suche in allen verfügbaren Keys
+        /*if (empty($routeResults)) {
+            foreach (array_keys($results->getAllAttributeResults()) as $key) {
+                if (str_contains($key, 'Route')) {
+                    debug("Found Route-related key: $key");
+                    $routeResults = $results->get($key);
+                    break;
+                }
+            }
+        }*/
+
+        #$discovery = new AttributeDiscoveryService($this->container, $pathProvider, $configuration);
+
+        #$dresults = ProcessedResults::fromArray($discovery->discoverAndProcess())->get(Route::class);
+
+        #debug(count($routeResults));
+        #dd(count($dresults));
+
+
+
+
+        #$cache = $this->container->get(Cache::class);
+
+        #$cache->forget('discovery_service');
+
+        #$processedResults = $cache->remember('discovery_service', function () use ($discovery) {
+#
+       #     // Attribute entdecken und verarbeiten
+        #    return $discovery->discoverAndProcess();
+#
+       # })->value;
+
+        #$results = ProcessedResults::fromArray($processedResults);
+
+        #$this->container->instance(ProcessedResults::class, $results);
+
+        #$this->executeInitializers($results);
+
+    }
+
+    private function executeInitializers(DiscoveryResults $initializerClasses): void
+    {
+        foreach ($initializerClasses->get(Initializer::class) as $initializerClass) {
+
+            $instance = $this->container->invoker->invoke($initializerClass['class'], $initializerClass['method']);
+
+            $this->container->instance($initializerClass['return'], $instance);
+        }
+    }
+}
diff --git a/src/Framework/Core/DOKUMENTATION.md b/src/Framework/Core/DOKUMENTATION.md
new file mode 100644
index 00000000..4435e80a
--- /dev/null
+++ b/src/Framework/Core/DOKUMENTATION.md
@@ -0,0 +1,45 @@
+# Core-Modul Dokumentation
+
+## Übersicht
+
+Das Core-Modul bildet das Herzstück des Frameworks und stellt grundlegende Funktionalitäten bereit, die von anderen Modulen genutzt werden.
+
+## Hauptkomponenten
+
+### Events und EventDispatcher
+
+Das Event-System ermöglicht die Kommunikation zwischen Komponenten über einen zentralen Event-Bus.
+
+**Kernklassen:**
+- `EventDispatcher`: Zentraler Service zum Registrieren und Auslösen von Events
+- Bekannte Events:
+  - `ApplicationBooted`
+  - `ErrorOccurred`
+  - `BeforeHandleRequest`
+  - `AfterHandleRequest`
+
+**Beispielverwendung:**
+```php
+// Event-Handler registrieren
+$eventDispatcher->addHandler('App\Framework\Core\Events\ApplicationBooted', function($event) {
+    // Event verarbeiten
+});
+```
+
+### PathProvider
+
+Stellt Pfadinformationen für verschiedene Bereiche der Anwendung bereit.
+
+**Hauptfunktionen:**
+- `getDataPath()`: Liefert Pfade zu Datenverzeichnissen
+
+## Integration mit anderen Modulen
+
+Das Core-Modul wird von vielen anderen Modulen verwendet, wie z.B.:
+
+- **Analytics-Modul**: Nutzt den EventDispatcher zum Tracking von Systemereignissen
+- **DI-Container**: Nutzt Core-Komponenten für die Initialisierung von Services
+
+## Architektur
+
+Das Core-Modul folgt einer ereignisgesteuerten Architektur, bei der Komponenten über Events miteinander kommunizieren können, anstatt direkte Abhängigkeiten zu haben.
diff --git a/src/Framework/Core/Discovery.php b/src/Framework/Core/Discovery.php
index ebde5bc6..56f41a99 100644
--- a/src/Framework/Core/Discovery.php
+++ b/src/Framework/Core/Discovery.php
@@ -4,168 +4,89 @@ declare(strict_types=1);
 
 namespace App\Framework\Core;
 
+use App\Framework\Discovery\FileScanner;
 use Exception;
-use RecursiveDirectoryIterator;
-use RecursiveIteratorIterator;
 use ReflectionClass;
-use ReflectionMethod;
 
 class Discovery
 {
-    /** @var array<string, AttributeMapper> */
-    private array $mapperMap;
-
-    private string $cacheFile;
+    private AttributeProcessor $attributeProcessor;
+    private FileScanner $fileScanner;
+    private ClassParser $classParser;
+    private DiscoveryCacheManager $cacheManager;
 
     /**
      * @param AttributeMapper[] $mappers
      */
-    public function __construct(AttributeMapper ...$mappers)
-    {
-        $this->mapperMap = [];
-        foreach ($mappers as $mapper) {
-            $this->mapperMap[$mapper->getAttributeClass()] = $mapper;
+    public function __construct(
+        ?string $srcDir = null,
+        AttributeMapper ...$mappers
+    ) {
+        // Automatisches Auffinden der Mapper, wenn ein Quellverzeichnis angegeben ist
+        if ($srcDir !== null) {
+            $locator = new AttributeMapperLocator();
+            $autoMappers = $locator->locateMappers($srcDir);
+            $mappers = array_merge($mappers, $autoMappers);
         }
 
-        $this->cacheFile = __DIR__ .'/../../../cache/discovery.cache.php';
+        // Initialisierung der Komponenten
+        $this->attributeProcessor = new AttributeProcessor($mappers);
+        $this->fileScanner = new FileScanner();
+        $this->classParser = new ClassParser();
+        $this->cacheManager = new DiscoveryCacheManager();
     }
 
+    /**
+     * Entdeckt und verarbeitet alle Attribute im angegebenen Verzeichnis
+     */
     public function discover(string $directory): array
     {
-        $hash = md5(realpath($directory));
+        $cacheFile = $this->cacheManager->getCachePathForDirectory($directory);
+        $latestMTime = $this->fileScanner->getLatestMTime($directory);
 
-        $this->cacheFile = __DIR__ ."/../../../cache/discovery_{$hash}.cache.php";
-
-        $latestMTime = $this->getLatestMTime($directory);
-        $data = $this->loadCache($latestMTime);
+        // Versuchen, aus dem Cache zu laden
+        $data = $this->cacheManager->loadCache($cacheFile, $latestMTime);
         if ($data !== null) {
             return $data;
         }
 
-        $results = [];
-        $rii = new RecursiveIteratorIterator(new RecursiveDirectoryIterator($directory));
-
-        foreach ($rii as $file) {
-            if (! $file->isFile() || $file->getExtension() !== 'php') {
-                continue;
-            }
-
-            try {
-                $className = $this->getClassNameFromFile($file->getPathname());
-
-                if (! $className || ! class_exists($className)) {
-                    continue;
-                }
-
-                $refClass = new ReflectionClass($className);
-
-                $this->discoverClass($refClass, $results);
-
-            } catch (Exception $e) {
-                error_log("Discovery Warning: Fehler in Datei {$file->getPathname()}: " . $e->getMessage());
-            }
-        }
+        // Keine Cache-Daten verfügbar, führe vollständige Entdeckung durch
+        $results = $this->performDiscovery($directory);
 
+        // Speichere Ergebnisse im Cache
         $results['__discovery_mtime'] = $latestMTime;
-        $this->storeCache($results);
+        $this->cacheManager->storeCache($cacheFile, $results);
+
+        // Entferne Metadaten für die Rückgabe
+        unset($results['__discovery_mtime']);
 
         return $results;
     }
 
-    private function discoverClass(ReflectionClass $refClass, array &$results): void
+    /**
+     * Führt die eigentliche Entdeckung durch
+     */
+    private function performDiscovery(string $directory): array
     {
-        $this->processAttributes($refClass, $results);
+        $results = [];
 
-        foreach ($refClass->getMethods(ReflectionMethod::IS_PUBLIC) as $method) {
-            $this->processAttributes($method, $results);
-        }
-    }
+        foreach ($this->fileScanner->scanDirectory($directory) as $file) {
+            try {
+                $className = $this->classParser->getClassNameFromFile($file->getPathname());
 
-    private function processAttributes(ReflectionClass|ReflectionMethod $ref, array &$results): void
-    {
-        foreach ($ref->getAttributes() as $attribute) {
-            $attrName = $attribute->getName();
-            if (! isset($this->mapperMap[$attrName])) {
-                continue;
-            }
-
-            $mapped = $this->mapperMap[$attrName]->map($ref, $attribute->newInstance());
-
-            if ($mapped !== null && $ref instanceof ReflectionMethod) {
-                $params = [];
-                foreach ($ref->getParameters() as $param) {
-                    $paramData = [
-                        'name' => $param->getName(),
-                        'type' => $param->getType()?->getName(),
-                        'isBuiltin' => $param->getType()?->isBuiltin() ?? false,
-                        'hasDefault' => $param->isDefaultValueAvailable(),
-                        'default' => $param->isDefaultValueAvailable() ? $param->getDefaultValue() : null,
-                        'attributes' => array_map(
-                            fn ($a) => $a->getName(),
-                            $param->getAttributes()
-                        ),
-                    ];
-                    $params[] = $paramData;
+                if (!$className || !class_exists($className)) {
+                    continue;
                 }
-                $mapped['parameters'] = $params;
-            }
 
-            if ($mapped !== null) {
-                $results[$attrName][] = $mapped;
-            }
-        }
-    }
+                $refClass = new ReflectionClass($className);
+                $this->attributeProcessor->processClass($refClass, $results);
 
-    public function getLatestMTime(string $directory): int
-    {
-        $maxMTime = 0;
-        $rii = new RecursiveIteratorIterator(new RecursiveDirectoryIterator($directory));
-        foreach ($rii as $file) {
-            if ($file->isFile() && $file->getExtension() === 'php') {
-                $mtime = $file->getMTime();
-                if ($mtime > $maxMTime) {
-                    $maxMTime = $mtime;
-                }
+            } catch (Exception $e) {
+                error_log("Discovery Warnung: Fehler in Datei {$file->getPathname()}: " . $e->getMessage());
             }
         }
 
-        return $maxMTime;
+        return $results;
     }
 
-    private function loadCache(int $latestMTime): ?array
-    {
-        if (! file_exists($this->cacheFile)) {
-            return null;
-        }
-        $data = include $this->cacheFile;
-        if (
-            ! is_array($data)
-            || ! isset($data['__discovery_mtime'])
-            || $data['__discovery_mtime'] !== $latestMTime
-        ) {
-            return null;
-        }
-        unset($data['__discovery_mtime']);
-
-        return $data;
-    }
-
-    private function storeCache(array $results): void
-    {
-        $export = var_export($results, true);
-        file_put_contents($this->cacheFile, "<?php\nreturn {$export};\n");
-    }
-
-    private function getClassNameFromFile(string $file): ?string
-    {
-        $contents = file_get_contents($file);
-        if (
-            preg_match('#namespace\s+([^;]+);#', $contents, $nsMatch)
-            && preg_match('/class\s+(\w+)/', $contents, $classMatch)
-        ) {
-            return trim($nsMatch[1]) . '\\' . trim($classMatch[1]);
-        }
-
-        return null;
-    }
 }
diff --git a/src/Framework/Core/DiscoveryCacheManager.php b/src/Framework/Core/DiscoveryCacheManager.php
new file mode 100644
index 00000000..c53d3ff2
--- /dev/null
+++ b/src/Framework/Core/DiscoveryCacheManager.php
@@ -0,0 +1,55 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Core;
+
+use RecursiveIteratorIterator;
+
+class DiscoveryCacheManager
+
+{
+    private string $baseCachePath;
+
+    public function __construct(?string $baseCachePath = null)
+    {
+        $this->baseCachePath = $baseCachePath ?? __DIR__ . '/../../../cache';
+    }
+
+    public function getCachePathForDirectory(string $directory): string
+    {
+        $hash = md5(realpath($directory));
+        return $this->baseCachePath . "/discovery_{$hash}.cache.php";
+    }
+
+    public function loadCache(string $cacheFile, int $latestMTime): ?array
+    {
+        if (!file_exists($cacheFile)) {
+            return null;
+        }
+
+        $data = include $cacheFile;
+        if (
+            !is_array($data)
+            || !isset($data['__discovery_mtime'])
+            || $data['__discovery_mtime'] !== $latestMTime
+        ) {
+            return null;
+        }
+
+        unset($data['__discovery_mtime']);
+        return $data;
+    }
+
+    public function storeCache(string $cacheFile, array $results): void
+    {
+        // Stellen Sie sicher, dass das Verzeichnis existiert
+        $cacheDir = dirname($cacheFile);
+        if (!is_dir($cacheDir)) {
+            mkdir($cacheDir, 0775, true);
+        }
+
+        $export = var_export($results, true);
+        file_put_contents($cacheFile, "<?php\nreturn {$export};\n");
+    }
+}
diff --git a/src/Framework/Core/DynamicRoute.php b/src/Framework/Core/DynamicRoute.php
index 7d219906..b802431d 100644
--- a/src/Framework/Core/DynamicRoute.php
+++ b/src/Framework/Core/DynamicRoute.php
@@ -8,10 +8,13 @@ final readonly class DynamicRoute implements Route
 {
     public function __construct(
         public string $regex,
-        public array $paramNames,
+        public array $paramNames, // ['id', 'userId'] - URL-Parameter-Namen
         public string $controller,
-        public string $method,
-        public array $parameters
-    ) {
-    }
+        public string $action,
+        public array $parameters,
+        public array $paramValues = [], // ['id' => '123', 'userId' => '456'] - URL-Parameter-Werte
+        public string $name = '',
+        public string $path = '',
+        public array $attributes = []
+    ) {}
 }
diff --git a/src/Framework/Core/ErrorHandler/GlobalErrorHandler.php b/src/Framework/Core/ErrorHandler/GlobalErrorHandler.php
new file mode 100644
index 00000000..fa4e91a2
--- /dev/null
+++ b/src/Framework/Core/ErrorHandler/GlobalErrorHandler.php
@@ -0,0 +1,218 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Core\ErrorHandler;
+
+use App\Application\Security\ExceptionHandlers\SecurityExceptionHandler;
+use App\Application\Security\Events\System\SystemAnomalyEvent;
+use App\Framework\Core\Events\EventDispatcher;
+use Psr\Log\LoggerInterface;
+use Throwable;
+
+final class GlobalErrorHandler
+{
+    public function __construct(
+        private LoggerInterface $logger,
+        private EventDispatcher $eventDispatcher,
+        private SecurityExceptionHandler $securityHandler,
+        private bool $debugMode = false
+    ) {}
+
+    public function handleException(Throwable $exception): void
+    {
+        // Zuerst Security Events dispatchen
+        $this->handleSecurityAspects($exception);
+
+        // Dann Standard Error Handling
+        $this->logException($exception);
+
+        if ($this->debugMode) {
+            $this->displayDebugInfo($exception);
+        } else {
+            $this->displayUserFriendlyError($exception);
+        }
+    }
+
+    public function handleError(int $severity, string $message, string $file, int $line): bool
+    {
+        // PHP Errors in Exceptions umwandeln für einheitliche Behandlung
+        $exception = new \ErrorException($message, 0, $severity, $file, $line);
+
+        // Security relevante Errors erkennen
+        if ($this->isSecurityRelevantError($severity, $message)) {
+            $this->handleSecurityAspects($exception);
+        }
+
+        $this->logError($severity, $message, $file, $line);
+
+        // true = Error wurde behandelt, false = PHP default error handler
+        return !$this->debugMode;
+    }
+
+    public function handleFatalError(): void
+    {
+        $error = error_get_last();
+        if ($error && $this->isFatal($error['type'])) {
+            $exception = new \ErrorException(
+                $error['message'],
+                0,
+                $error['type'],
+                $error['file'],
+                $error['line']
+            );
+
+            $this->handleSecurityAspects($exception);
+            $this->logException($exception);
+
+            if (!$this->debugMode) {
+                $this->displayFatalErrorPage();
+            }
+        }
+    }
+
+    private function handleSecurityAspects(Throwable $exception): void
+    {
+        try {
+            // Delegiere an speziellen Security Exception Handler
+            $this->securityHandler->handle($exception);
+
+            // Zusätzlich: System-weite Anomalien erkennen
+            if ($this->isSystemAnomaly($exception)) {
+                $this->dispatchSystemAnomaly($exception);
+            }
+
+        } catch (Throwable $securityHandlingException) {
+            // Fallback: Security Handler selbst darf nicht crashen
+            $this->logger->critical('Security exception handler failed', [
+                'original_exception' => $exception->getMessage(),
+                'security_handler_exception' => $securityHandlingException->getMessage(),
+                'trace' => $securityHandlingException->getTraceAsString()
+            ]);
+        }
+    }
+
+    private function isSecurityRelevantError(int $severity, string $message): bool
+    {
+        // Sicherheitskritische PHP Errors identifizieren
+        $securityKeywords = [
+            'permission denied', 'access denied', 'authentication',
+            'authorization', 'file_get_contents', 'file_put_contents',
+            'openssl_', 'hash_', 'password_', 'session_',
+            'mysqli_', 'pdo_', 'curl_', 'file_upload'
+        ];
+
+        $messageLower = strtolower($message);
+        foreach ($securityKeywords as $keyword) {
+            if (strpos($messageLower, $keyword) !== false) {
+                return true;
+            }
+        }
+
+        // Bestimmte Error-Level sind grundsätzlich sicherheitsrelevant
+        return in_array($severity, [E_ERROR, E_CORE_ERROR, E_COMPILE_ERROR, E_USER_ERROR]);
+    }
+
+    private function isSystemAnomaly(Throwable $exception): bool
+    {
+        // System-Anomalien erkennen
+        return $exception instanceof \Error ||
+               $exception instanceof \OutOfMemoryError ||
+               $exception instanceof \ParseError ||
+               strpos($exception->getMessage(), 'Maximum execution time') !== false ||
+               strpos($exception->getMessage(), 'Allowed memory size') !== false;
+    }
+
+    private function dispatchSystemAnomaly(Throwable $exception): void
+    {
+        $metrics = [
+            'memory_usage' => memory_get_usage(true),
+            'memory_peak' => memory_get_peak_usage(true),
+            'execution_time' => microtime(true) - ($_SERVER['REQUEST_TIME_FLOAT'] ?? microtime(true))
+        ];
+
+        $severity = match (true) {
+            $exception instanceof \OutOfMemoryError => 'critical',
+            $exception instanceof \Error => 'high',
+            default => 'medium'
+        };
+
+        $this->eventDispatcher->dispatch(new SystemAnomalyEvent(
+            anomalyType: get_class($exception),
+            description: $exception->getMessage(),
+            metrics: $metrics,
+            severity: $severity
+        ));
+    }
+
+    private function isFatal(int $type): bool
+    {
+        return in_array($type, [E_ERROR, E_CORE_ERROR, E_COMPILE_ERROR, E_PARSE]);
+    }
+
+    private function logException(Throwable $exception): void
+    {
+        $context = [
+            'exception_class' => get_class($exception),
+            'message' => $exception->getMessage(),
+            'file' => $exception->getFile(),
+            'line' => $exception->getLine(),
+            'trace' => $exception->getTraceAsString(),
+            'user_id' => $_SESSION['user_id'] ?? null,
+            'request_uri' => $_SERVER['REQUEST_URI'] ?? null,
+            'request_method' => $_SERVER['REQUEST_METHOD'] ?? null,
+            'user_agent' => $_SERVER['HTTP_USER_AGENT'] ?? null,
+            'remote_addr' => $_SERVER['REMOTE_ADDR'] ?? null
+        ];
+
+        $this->logger->error('Unhandled exception: ' . $exception->getMessage(), $context);
+    }
+
+    private function logError(int $severity, string $message, string $file, int $line): void
+    {
+        $level = $this->mapErrorSeverityToLogLevel($severity);
+
+        $this->logger->log($level, "PHP Error: {$message}", [
+            'severity' => $severity,
+            'file' => $file,
+            'line' => $line,
+            'user_id' => $_SESSION['user_id'] ?? null
+        ]);
+    }
+
+    private function mapErrorSeverityToLogLevel(int $severity): string
+    {
+        return match ($severity) {
+            E_ERROR, E_CORE_ERROR, E_COMPILE_ERROR, E_USER_ERROR => 'error',
+            E_WARNING, E_CORE_WARNING, E_COMPILE_WARNING, E_USER_WARNING => 'warning',
+            E_NOTICE, E_USER_NOTICE => 'notice',
+            E_STRICT => 'info',
+            default => 'debug'
+        };
+    }
+
+    private function displayDebugInfo(Throwable $exception): void
+    {
+        echo "<h1>Exception: " . get_class($exception) . "</h1>";
+        echo "<p><strong>Message:</strong> " . htmlspecialchars($exception->getMessage()) . "</p>";
+        echo "<p><strong>File:</strong> " . htmlspecialchars($exception->getFile()) . ":" . $exception->getLine() . "</p>";
+        echo "<pre>" . htmlspecialchars($exception->getTraceAsString()) . "</pre>";
+    }
+
+    private function displayUserFriendlyError(Throwable $exception): void
+    {
+        http_response_code(500);
+        echo "<!DOCTYPE html><html><head><title>Fehler</title></head><body>";
+        echo "<h1>Es ist ein Fehler aufgetreten</h1>";
+        echo "<p>Entschuldigung, es ist ein unerwarteter Fehler aufgetreten. Bitte versuchen Sie es später erneut.</p>";
+        echo "</body></html>";
+    }
+
+    private function displayFatalErrorPage(): void
+    {
+        http_response_code(500);
+        echo "<!DOCTYPE html><html><head><title>Schwerwiegender Fehler</title></head><body>";
+        echo "<h1>Schwerwiegender Systemfehler</h1>";
+        echo "<p>Die Anwendung musste aufgrund eines kritischen Fehlers beendet werden.</p>";
+        echo "</body></html>";
+    }
+}
diff --git a/src/Framework/Core/Events/AfterEmitResponse.php b/src/Framework/Core/Events/AfterEmitResponse.php
new file mode 100644
index 00000000..c591754f
--- /dev/null
+++ b/src/Framework/Core/Events/AfterEmitResponse.php
@@ -0,0 +1,8 @@
+<?php
+
+namespace App\Framework\Core\Events;
+
+class AfterEmitResponse
+{
+
+}
diff --git a/src/Framework/Core/Events/AfterHandleRequest.php b/src/Framework/Core/Events/AfterHandleRequest.php
new file mode 100644
index 00000000..e479ac61
--- /dev/null
+++ b/src/Framework/Core/Events/AfterHandleRequest.php
@@ -0,0 +1,8 @@
+<?php
+
+namespace App\Framework\Core\Events;
+
+class AfterHandleRequest
+{
+
+}
diff --git a/src/Framework/Core/Events/ApplicationBooted.php b/src/Framework/Core/Events/ApplicationBooted.php
new file mode 100644
index 00000000..afd93897
--- /dev/null
+++ b/src/Framework/Core/Events/ApplicationBooted.php
@@ -0,0 +1,14 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Core\Events;
+
+final readonly class ApplicationBooted
+{
+    public function __construct(
+        public \DateTimeImmutable $bootTime,
+        public string $environment,
+        public string $version = 'dev',
+        public \DateTimeImmutable $occurredAt = new \DateTimeImmutable()
+    ) {}
+}
diff --git a/src/Framework/Core/Events/BeforeEmitResponse.php b/src/Framework/Core/Events/BeforeEmitResponse.php
new file mode 100644
index 00000000..c554f9b8
--- /dev/null
+++ b/src/Framework/Core/Events/BeforeEmitResponse.php
@@ -0,0 +1,8 @@
+<?php
+
+namespace App\Framework\Core\Events;
+
+class BeforeEmitResponse
+{
+
+}
diff --git a/src/Framework/Core/Events/BeforeHandleRequest.php b/src/Framework/Core/Events/BeforeHandleRequest.php
new file mode 100644
index 00000000..d969ea64
--- /dev/null
+++ b/src/Framework/Core/Events/BeforeHandleRequest.php
@@ -0,0 +1,8 @@
+<?php
+
+namespace App\Framework\Core\Events;
+
+class BeforeHandleRequest
+{
+
+}
diff --git a/src/Framework/Core/Events/ErrorOccurred.php b/src/Framework/Core/Events/ErrorOccurred.php
new file mode 100644
index 00000000..5ef45d3b
--- /dev/null
+++ b/src/Framework/Core/Events/ErrorOccurred.php
@@ -0,0 +1,14 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Core\Events;
+
+final readonly class ErrorOccurred
+{
+    public function __construct(
+        public \Throwable $error,
+        public string $context = '',
+        public ?string $requestId = null,
+        public \DateTimeImmutable $occurredAt = new \DateTimeImmutable()
+    ) {}
+}
diff --git a/src/Framework/Core/Events/EventCompilerPass.php b/src/Framework/Core/Events/EventCompilerPass.php
new file mode 100644
index 00000000..04c55069
--- /dev/null
+++ b/src/Framework/Core/Events/EventCompilerPass.php
@@ -0,0 +1,40 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Core\Events;
+
+use App\Framework\DI\DefaultContainer;
+
+/**
+ * Führt abschließende Konfigurationen für das Event-System durch
+ */
+final class EventCompilerPass
+{
+    /**
+     * Richtet zusätzliche Event-Konfigurationen ein
+     *
+     * @param DefaultContainer $container Der DI-Container
+     * @param EventDispatcher $dispatcher Der EventDispatcher
+     */
+    public static function process(DefaultContainer $container, EventDispatcher $dispatcher): void
+    {
+        // Hier können weitere Event-Handler oder -Konfigurationen eingerichtet werden
+        // Beispiel: System-Events registrieren, die nicht über Attribute verfügbar sind
+
+        // Beispiel für einen Shutdown-Handler
+        register_shutdown_function(function () use ($dispatcher, $container) {
+            $error = error_get_last();
+            if ($error !== null && in_array($error['type'], [E_ERROR, E_PARSE, E_CORE_ERROR, E_COMPILE_ERROR])) {
+                $exception = new \ErrorException(
+                    $error['message'],
+                    0,
+                    $error['type'],
+                    $error['file'],
+                    $error['line']
+                );
+
+                $dispatcher->dispatch(new ErrorOccurred($exception, 'shutdown'));
+            }
+        });
+    }
+}
diff --git a/src/Framework/Core/Events/EventDispatcher.php b/src/Framework/Core/Events/EventDispatcher.php
new file mode 100644
index 00000000..9909bf22
--- /dev/null
+++ b/src/Framework/Core/Events/EventDispatcher.php
@@ -0,0 +1,188 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Core\Events;
+
+use App\Framework\DI\DefaultContainer;
+
+/**
+ * Der EventDispatcher ist verantwortlich für die Verarbeitung von Events
+ * und das Aufrufen der entsprechenden Event-Handler
+ */
+final class EventDispatcher
+{
+    /** @var array<string, array> Mapping von Event-Typen zu Handlern */
+    private array $handlers = [];
+
+    /** @var bool Gibt an, ob der EventDispatcher initialisiert wurde */
+    private bool $initialized = false;
+
+    /**
+     * @param DefaultContainer $container Der DI-Container
+     * @param array|null $eventHandlers Array mit Event-Handlern aus der Autodiscovery
+     */
+    public function __construct(
+        private readonly DefaultContainer $container,
+        private readonly ?array           $eventHandlers = null
+    ) {}
+
+    /**
+     * Initialisiert den EventDispatcher mit den Event-Handlern
+     */
+    private function initialize(): void
+    {
+        if ($this->initialized) {
+            return;
+        }
+
+        $this->initialized = true;
+
+        if ($this->eventHandlers === null) {
+            return;
+        }
+
+        foreach ($this->eventHandlers as $handler) {
+            $eventClass = $handler['event_class'];
+            $this->handlers[$eventClass][] = $handler;
+        }
+    }
+
+    /**
+     * Dispatcht ein Event an alle registrierten Handler
+     *
+     * @param object $event Das zu dispatchende Event-Objekt
+     * @return array<mixed> Ergebnisse der Event-Handler
+     */
+    public function dispatch(object $event): array
+    {
+        $this->initialize();
+
+        $eventClass = get_class($event);
+        $results = [];
+
+        // Exakte Übereinstimmung prüfen
+        if (isset($this->handlers[$eventClass])) {
+            foreach ($this->handlers[$eventClass] as $handler) {
+                $result = $this->invokeHandler($handler, $event);
+                $results[] = $result;
+
+                // Wenn ein Handler die Propagation stoppt, abbrechen
+                if (isset($handler['attribute_data']) && $handler['attribute_data']['stopPropagation'] ?? false) {
+                    return $results;
+                }
+            }
+        }
+
+        // Prüfen auf Handler für Basisklassen/Interfaces
+        foreach ($this->handlers as $handledEventClass => $handlersList) {
+            if ($handledEventClass === $eventClass) {
+                continue; // Bereits verarbeitet
+            }
+
+            if (is_subclass_of($event, $handledEventClass) ||
+                ($event instanceof $handledEventClass)) {
+                foreach ($handlersList as $handler) {
+                    $result = $this->invokeHandler($handler, $event);
+                    $results[] = $result;
+
+                    // Wenn ein Handler die Propagation stoppt, abbrechen
+                    if (isset($handler['attribute_data']) && $handler['attribute_data']['stopPropagation'] ?? false) {
+                        return $results;
+                    }
+                }
+            }
+        }
+
+        return $results;
+    }
+
+    public function __invoke(object $event): array
+    {
+        return $this->dispatch($event);
+    }
+
+    /**
+     * Ruft einen Event-Handler auf
+     *
+     * @param array $handler Handler-Definition
+     * @param object $event Event-Objekt
+     * @return mixed Ergebnis des Handler-Aufrufs
+     */
+    private function invokeHandler(array $handler, object $event): mixed
+    {
+        if (isset($handler['callable'])) {
+            // Callable direkt aufrufen
+            return ($handler['callable'])($event);
+        }
+
+        $handlerClass = $handler['class'];
+        $methodName = $handler['method'];
+
+        // Handler-Instanz aus dem Container holen oder erstellen
+        $handlerInstance = $this->container->get($handlerClass);
+
+        // Handler-Methode aufrufen
+        return $handlerInstance->$methodName($event);
+    }
+
+    /**
+     * Registriert einen Event-Handler manuell
+     *
+     * @param string $eventClass Vollqualifizierter Klassenname des Events
+     * @param callable $handler Der Handler, der aufgerufen werden soll
+     * @param int|null $priority Priorität des Handlers (höhere Werte werden zuerst ausgeführt)
+     * @param bool $stopPropagation Gibt an, ob die Event-Propagation nach diesem Handler gestoppt werden soll
+     * @return self
+     */
+    public function addHandler(
+        string $eventClass,
+        callable $handler,
+        ?int $priority = null,
+        bool $stopPropagation = false
+    ): self {
+        $this->initialize();
+
+        // OnEvent-Attribut für die Priorität und Propagation erstellen
+        $attribute = new OnEvent($priority, $stopPropagation);
+
+        $this->handlers[$eventClass][] = [
+            'callable' => $handler,
+            'attribute_data' => [
+                'priority' => $priority ?? 0,
+                'stopPropagation' => $stopPropagation
+            ]
+
+        ];
+
+        // Handlers nach Priorität sortieren
+        if (isset($this->handlers[$eventClass]) && count($this->handlers[$eventClass]) > 1) {
+            usort($this->handlers[$eventClass], function ($a, $b) {
+                $priorityA = isset($a['attribute_data']) ? ($a['attribute_data']['priority'] ?? 0) : 0;
+                $priorityB = isset($b['attribute_data']) ? ($b['attribute_data']['priority'] ?? 0) : 0;
+
+                return $priorityB <=> $priorityA;
+            });
+        }
+
+        return $this;
+    }
+
+    /**
+     * Prüft, ob Handler für den angegebenen Event-Typ registriert sind
+     *
+     * @param string $eventClass Event-Klasse
+     * @return bool True, wenn Handler existieren
+     */
+    public function hasHandlersFor(string $eventClass): bool
+    {
+        $this->initialize();
+
+        if (isset($this->handlers[$eventClass]) && !empty($this->handlers[$eventClass])) {
+            return true;
+        }
+
+        // Prüfen auf Handler für Basisklassen/Interfaces
+        return array_any(array_keys($this->handlers), fn($handledEventClass) => is_subclass_of($eventClass, $handledEventClass));
+
+    }
+}
diff --git a/src/Framework/Core/Events/EventDispatcherInitializer.php b/src/Framework/Core/Events/EventDispatcherInitializer.php
new file mode 100644
index 00000000..f264e4c8
--- /dev/null
+++ b/src/Framework/Core/Events/EventDispatcherInitializer.php
@@ -0,0 +1,21 @@
+<?php
+
+namespace App\Framework\Core\Events;
+
+use App\Framework\DI\Container;
+use App\Framework\DI\Initializer;
+use App\Framework\Discovery\Results\DiscoveryResults;
+
+final readonly class EventDispatcherInitializer
+{
+    public function __construct(
+        private Container        $container,
+        private DiscoveryResults $results
+    ){}
+
+    #[Initializer]
+    public function __invoke(): EventDispatcher
+    {
+        return new EventDispatcher($this->container, $this->results->get(OnEvent::class));
+    }
+}
diff --git a/src/Framework/Core/Events/EventHandlerCompiler.php b/src/Framework/Core/Events/EventHandlerCompiler.php
new file mode 100644
index 00000000..b5bb7be5
--- /dev/null
+++ b/src/Framework/Core/Events/EventHandlerCompiler.php
@@ -0,0 +1,41 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Core\Events;
+
+use App\Framework\Core\AttributeCompiler;
+
+/**
+ * Compiler für Event-Handler
+ */
+final class EventHandlerCompiler implements AttributeCompiler
+{
+    /**
+     * Gibt die Attributklasse zurück, die dieser Compiler verarbeitet
+     */
+    public function getAttributeClass(): string
+    {
+        return OnEvent::class;
+    }
+
+    /**
+     * Kompiliert die Event-Handler
+     *
+     * @param array $attributeData Array mit Attributdaten aus dem Mapper
+     * @return array Kompilierte Event-Handler
+     */
+    public function compile(array $attributeData): array
+    {
+        // Sortieren nach Priorität (höhere Werte zuerst)
+        usort($attributeData, function ($a, $b) {
+            $priorityA = $a['attribute']->priority ?? 0;
+            $priorityB = $b['attribute']->priority ?? 0;
+
+            return $priorityB <=> $priorityA;
+        });
+
+        // Weitere Kompilierung wenn nötig (z.B. Validierung)
+
+        return $attributeData;
+    }
+}
diff --git a/src/Framework/Core/Events/EventHandlerMapper.php b/src/Framework/Core/Events/EventHandlerMapper.php
new file mode 100644
index 00000000..b8029764
--- /dev/null
+++ b/src/Framework/Core/Events/EventHandlerMapper.php
@@ -0,0 +1,80 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Core\Events;
+
+use App\Framework\Core\AttributeMapper;
+use ReflectionClass;
+use ReflectionMethod;
+
+/**
+ * Mapper für das OnEvent-Attribut
+ */
+final class EventHandlerMapper implements AttributeMapper
+{
+    /**
+     * Gibt die Attributklasse zurück, die dieser Mapper verarbeitet
+     */
+    public function getAttributeClass(): string
+    {
+        return OnEvent::class;
+    }
+
+    /**
+     * Implementiert die map-Methode aus dem AttributeMapper-Interface
+     *
+     * @param object $reflectionTarget Das Reflektionsobjekt (ReflectionClass|ReflectionMethod)
+     * @param object $attributeInstance Die Attributinstanz
+     * @return array|null Die Attributdaten oder null, wenn nicht verarbeitet werden kann
+     */
+    public function map(object $reflectionTarget, object $attributeInstance): ?array
+    {
+        if (!($reflectionTarget instanceof ReflectionMethod)) {
+            return null;
+        }
+
+        $parameters = $reflectionTarget->getParameters();
+
+        // Event-Handler müssen mindestens einen Parameter haben (das Event)
+        if (count($parameters) < 1) {
+            return null;
+        }
+
+        $eventType = $parameters[0]->getType();
+        if (!$eventType || $eventType->isBuiltin()) {
+            return null;
+        }
+
+        $eventClassName = $eventType->getName();
+
+        return [
+            'class' => $reflectionTarget->getDeclaringClass()->getName(),
+            'method' => $reflectionTarget->getName(),
+            'event_class' => $eventClassName,
+            #'reflection' => $reflectionTarget,
+            'attribute_data' => [
+                'priority' => $attributeInstance->priority ?? 0,
+                'stopPropagation' => $attributeInstance->stopPropagation ?? false
+            ],
+        ];
+    }
+
+    /**
+     * Verarbeitet ein Event-Handler-Attribut
+     *
+     * @param array $attributeData Array mit Attributdaten aus der Discovery
+     * @return array Verarbeitete Attributdaten
+     */
+    public function process(array $attributeData): array
+    {
+        // Nach Priorität sortieren (höhere Werte zuerst)
+        usort($attributeData, function ($a, $b) {
+            $priorityA = $a['attribute']->priority ?? 0;
+            $priorityB = $b['attribute']->priority ?? 0;
+
+            return $priorityB <=> $priorityA;
+        });
+
+        return $attributeData;
+    }
+}
diff --git a/src/Framework/Core/Events/OnEvent.php b/src/Framework/Core/Events/OnEvent.php
new file mode 100644
index 00000000..8fdab6b2
--- /dev/null
+++ b/src/Framework/Core/Events/OnEvent.php
@@ -0,0 +1,24 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Core\Events;
+
+/**
+ * Attribut, das eine Methode als Event-Handler kennzeichnet.
+ *
+ * Beispiel:
+ * #[OnEvent]
+ * public function handleUserRegistered(UserRegistered $event): void { ... }
+ */
+#[\Attribute(\Attribute::TARGET_METHOD)]
+final class OnEvent
+{
+    /**
+     * @param int|null $priority Priorität des Handlers (höhere Werte werden zuerst ausgeführt)
+     * @param bool $stopPropagation Gibt an, ob die Event-Propagation nach diesem Handler gestoppt werden soll
+     */
+    public function __construct(
+        public readonly ?int $priority = null,
+        public readonly bool $stopPropagation = false
+    ) {}
+}
diff --git a/src/Framework/Core/Events/UserRegistered.php b/src/Framework/Core/Events/UserRegistered.php
new file mode 100644
index 00000000..80be4587
--- /dev/null
+++ b/src/Framework/Core/Events/UserRegistered.php
@@ -0,0 +1,18 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Core\Events;
+
+/**
+ * Event, das nach der Registrierung eines Benutzers ausgelöst wird
+ */
+final readonly class UserRegistered
+{
+    public function __construct(
+        public string $userId,
+        public string $email,
+        public string $username,
+        public \DateTimeImmutable $registeredAt = new \DateTimeImmutable(),
+        public \DateTimeImmutable $occurredAt = new \DateTimeImmutable()
+    ) {}
+}
diff --git a/src/Framework/Core/Exceptions/InvalidRouteCacheFormatException.php b/src/Framework/Core/Exceptions/InvalidRouteCacheFormatException.php
new file mode 100644
index 00000000..2ebf013a
--- /dev/null
+++ b/src/Framework/Core/Exceptions/InvalidRouteCacheFormatException.php
@@ -0,0 +1,23 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Core\Exceptions;
+
+use App\Framework\Exception\FrameworkException;
+
+final class InvalidRouteCacheFormatException extends FrameworkException
+{
+    public function __construct(
+        string $cacheFile,
+        int $code = 0,
+        ?\Throwable $previous = null
+    ) {
+        parent::__construct(
+            message: "Invalid route cache format.",
+            code: $code,
+            previous: $previous,
+            context: ['cacheFile' => $cacheFile]
+        );
+    }
+}
diff --git a/src/Framework/Core/Exceptions/RouteCacheException.php b/src/Framework/Core/Exceptions/RouteCacheException.php
new file mode 100644
index 00000000..223102ab
--- /dev/null
+++ b/src/Framework/Core/Exceptions/RouteCacheException.php
@@ -0,0 +1,23 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Core\Exceptions;
+
+use App\Framework\Exception\FrameworkException;
+
+final class RouteCacheException extends FrameworkException
+{
+    public function __construct(
+        string $cacheFile,
+        int $code = 0,
+        ?\Throwable $previous = null
+    ) {
+        parent::__construct(
+            message: "Route cache file not found: {$cacheFile}",
+            code: $code,
+            previous: $previous,
+            context: ['cacheFile' => $cacheFile]
+        );
+    }
+}
diff --git a/src/Framework/Core/ImplementationLocator.md b/src/Framework/Core/ImplementationLocator.md
new file mode 100644
index 00000000..49191889
--- /dev/null
+++ b/src/Framework/Core/ImplementationLocator.md
@@ -0,0 +1,17 @@
+````php
+
+// Beispiel: Alle Repository-Implementierungen finden
+$locator = new InterfaceImplementationLocator();
+$repositories = $locator->locate(__DIR__ . '/../src', Repository::class);
+
+// Beispiel: Alle EventListener-Implementierungen finden, ohne sie zu instanziieren
+$eventListeners = $locator->locate(__DIR__ . '/../src', EventListener::class, false);
+
+// Beispiel: Mit einem Factory-Pattern verwenden
+$serviceClasses = $locator->locate(__DIR__ . '/../src', Service::class, false);
+$services = [];
+foreach ($serviceClasses as $serviceClass) {
+    $services[] = $serviceFactory->create($serviceClass);
+}
+
+````
diff --git a/src/Framework/Core/InterfaceImplementationLocator.php b/src/Framework/Core/InterfaceImplementationLocator.php
new file mode 100644
index 00000000..927c88d8
--- /dev/null
+++ b/src/Framework/Core/InterfaceImplementationLocator.php
@@ -0,0 +1,77 @@
+<?php
+
+namespace App\Framework\Core;
+
+use RecursiveDirectoryIterator;
+use RecursiveIteratorIterator;
+use ReflectionClass;
+use Throwable;
+
+class InterfaceImplementationLocator
+{
+    /**
+     * Findet alle Klassen, die ein bestimmtes Interface implementieren
+     *
+     * @param string $directory Das Basisverzeichnis, in dem gesucht werden soll
+     * @param string $interfaceName Der vollständige Name des Interfaces (mit Namespace)
+     * @param bool $instantiate Gibt an, ob die gefundenen Klassen instanziiert werden sollen
+     * @return array<int, object|string> Array von Instanzen oder Klassennamen
+     */
+    public function locate(string $directory, string $interfaceName, bool $instantiate = true): array
+    {
+        $implementations = [];
+        $rii = new RecursiveIteratorIterator(new RecursiveDirectoryIterator($directory));
+
+        foreach ($rii as $file) {
+            if (!$file->isFile() || $file->getExtension() !== 'php') {
+                continue;
+            }
+
+            try {
+                $className = $this->getClassNameFromFile($file->getPathname());
+
+                if (!$className || !class_exists($className)) {
+                    continue;
+                }
+
+                $refClass = new ReflectionClass($className);
+
+                // Überprüfen, ob die Klasse das gewünschte Interface implementiert
+                if ($refClass->implementsInterface($interfaceName) &&
+                    !$refClass->isAbstract() &&
+                    !$refClass->isInterface()) {
+
+                    if ($instantiate) {
+                        // Prüfen, ob der Konstruktor Parameter hat
+                        $constructor = $refClass->getConstructor();
+                        if ($constructor === null || $constructor->getNumberOfRequiredParameters() === 0) {
+                            $implementations[] = $refClass->newInstance();
+                        } else {
+                            // Bei Konstruktoren mit Pflichtparametern nur den Klassennamen zurückgeben
+                            $implementations[] = $className;
+                        }
+                    } else {
+                        $implementations[] = $className;
+                    }
+                }
+            } catch (Throwable $e) {
+                #error_log("InterfaceImplementationLocator Warnung: Fehler in Datei {$file->getPathname()}: " . $e->getMessage());
+            }
+        }
+
+        return $implementations;
+    }
+
+    private function getClassNameFromFile(string $file): ?string
+    {
+        $contents = file_get_contents($file);
+        if (
+            preg_match('#namespace\s+([^;]+);#', $contents, $nsMatch)
+            && preg_match('/class\s+(\w+)/', $contents, $classMatch)
+        ) {
+            return trim($nsMatch[1]) . '\\' . trim($classMatch[1]);
+        }
+
+        return null;
+    }
+}
diff --git a/src/Framework/Core/InterfaceImplementationVisitor.php b/src/Framework/Core/InterfaceImplementationVisitor.php
new file mode 100644
index 00000000..8eea251f
--- /dev/null
+++ b/src/Framework/Core/InterfaceImplementationVisitor.php
@@ -0,0 +1,179 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Core;
+
+use App\Framework\Cache\Cache;
+use App\Framework\Discovery\FileVisitor;
+
+/**
+ * Visitor zum Auffinden von Interface-Implementierungen
+ */
+final class InterfaceImplementationVisitor implements FileVisitor
+{
+    private array $interfaces = [];
+    private array $implementations = [];
+    private array $implementationsByClass = [];
+
+    /**
+     * @param array $targetInterfaces Die zu suchenden Interfaces
+     */
+    public function __construct(private readonly array $targetInterfaces = [])
+    {
+    }
+
+    public function onScanStart(): void
+    {
+        $this->implementations = [];
+        $this->implementationsByClass = [];
+    }
+
+    public function onIncrementalScanStart(): void
+    {
+        // Bei inkrementellem Scan behalten wir vorhandene Implementierungen
+        // und aktualisieren sie mit neuen Daten
+    }
+
+    public function onIncrementalScanComplete(): void
+    {
+        // Sortiere nach inkrementellem Scan
+        $this->sortImplementations();
+    }
+
+    public function visitClass(string $className, string $filePath): void
+    {
+        if (!class_exists($className)) {
+            return;
+        }
+
+        try {
+            $reflection = new \ReflectionClass($className);
+
+            // Abstrakte Klassen und Interfaces überspringen
+            if ($reflection->isAbstract() || $reflection->isInterface()) {
+                return;
+            }
+
+            // Alte Einträge für diese Klasse entfernen (wichtig für inkrementelle Scans)
+            $this->removeImplementationsForClass($className);
+
+            // Prüfe, ob die Klasse eines der Ziel-Interfaces implementiert
+            foreach ($this->targetInterfaces as $interface) {
+                if ($reflection->implementsInterface($interface)) {
+                    if (!isset($this->implementations[$interface])) {
+                        $this->implementations[$interface] = [];
+                    }
+
+                    // Prüfe auf Duplikate
+                    if (!in_array($className, $this->implementations[$interface])) {
+                        $this->implementations[$interface][] = $className;
+
+                        // Umgekehrten Index für schnelleren Zugriff aufbauen
+                        if (!isset($this->implementationsByClass[$className])) {
+                            $this->implementationsByClass[$className] = [];
+                        }
+                        $this->implementationsByClass[$className][] = $interface;
+                    }
+                }
+            }
+        } catch (\Throwable $e) {
+            error_log("Fehler beim Prüfen der Interface-Implementierung für {$className}: " . $e->getMessage());
+        }
+    }
+
+    /**
+     * Entfernt alle Interface-Implementierungen für eine bestimmte Klasse
+     */
+    private function removeImplementationsForClass(string $className): void
+    {
+        if (!isset($this->implementationsByClass[$className])) {
+            return;
+        }
+
+        foreach ($this->implementationsByClass[$className] as $interface) {
+            if (isset($this->implementations[$interface])) {
+                $key = array_search($className, $this->implementations[$interface]);
+                if ($key !== false) {
+                    unset($this->implementations[$interface][$key]);
+                    // Array-Indizes neu numerieren
+                    $this->implementations[$interface] = array_values($this->implementations[$interface]);
+                }
+            }
+        }
+
+        unset($this->implementationsByClass[$className]);
+    }
+
+    public function onScanComplete(): void
+    {
+        // Sortiere Implementierungen für konsistente Reihenfolge
+        $this->sortImplementations();
+    }
+
+    /**
+     * Sortiert alle Implementierungen für konsistente Ergebnisse
+     */
+    private function sortImplementations(): void
+    {
+        foreach ($this->implementations as &$classes) {
+            sort($classes);
+        }
+    }
+
+    public function loadFromCache(Cache $cache): void
+    {
+        $cacheItem = $cache->get($this->getCacheKey());
+        if ($cacheItem->isHit) {
+            if (is_array($cacheItem->value) && isset($cacheItem->value['implementations'], $cacheItem->value['byClass'])) {
+                $this->implementations = $cacheItem->value['implementations'];
+                $this->implementationsByClass = $cacheItem->value['byClass'];
+            }
+        }
+    }
+
+    public function getCacheKey(): string
+    {
+        return 'interface_implementations';
+    }
+
+    public function getCacheableData(): mixed
+    {
+        return [
+            'implementations' => $this->implementations,
+            'byClass' => $this->implementationsByClass
+        ];
+    }
+
+    /**
+     * Gibt alle Implementierungen eines Interfaces zurück
+     */
+    public function getImplementations(string $interface): array
+    {
+        return $this->implementations[$interface] ?? [];
+    }
+
+    /**
+     * Prüft, ob eine Klasse ein bestimmtes Interface implementiert
+     */
+    public function doesImplement(string $className, string $interface): bool
+    {
+        return isset($this->implementationsByClass[$className]) &&
+               in_array($interface, $this->implementationsByClass[$className]);
+    }
+
+    /**
+     * Gibt alle Interfaces zurück, die eine Klasse implementiert
+     */
+    public function getClassInterfaces(string $className): array
+    {
+        return $this->implementationsByClass[$className] ?? [];
+    }
+
+    /**
+     * Gibt alle gefundenen Implementierungen zurück
+     */
+    public function getAllImplementations(): array
+    {
+        return $this->implementations;
+    }
+}
diff --git a/src/Framework/Core/PathProvider.php b/src/Framework/Core/PathProvider.php
new file mode 100644
index 00000000..6bf83545
--- /dev/null
+++ b/src/Framework/Core/PathProvider.php
@@ -0,0 +1,135 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Core;
+
+/**
+ * Optimierter PathProvider mit Caching
+ */
+final class PathProvider
+{
+    private string $basePath;
+    private array $resolvedPaths = [];
+    private ?array $namespacePaths = null {
+        get {
+            if ($this->namespacePaths !== null) {
+                return $this->namespacePaths;
+            }
+
+            // Aus composer.json auslesen
+            $composerJsonPath = $this->basePath . '/composer.json';
+            if (!file_exists($composerJsonPath)) {
+                return $this->namespacePaths = [];
+            }
+
+            $composerJson = json_decode(file_get_contents($composerJsonPath), true);
+            $this->namespacePaths = [];
+
+            if (isset($composerJson['autoload']['psr-4'])) {
+                foreach ($composerJson['autoload']['psr-4'] as $namespace => $path) {
+                    $this->namespacePaths[$namespace] = $this->resolvePath($path);
+                }
+            }
+
+            return $this->namespacePaths;
+        }
+    }
+
+    public function __construct(string $basePath)
+    {
+        $this->basePath = rtrim($basePath, '/');
+    }
+
+    /**
+     * Gibt den Basispfad des Projekts zurück
+     */
+    public function getBasePath(): string
+    {
+        return $this->basePath;
+    }
+
+    /**
+     * Löst einen relativen Pfad zum Basispfad auf
+     */
+    public function resolvePath(string $relativePath): string
+    {
+        if (isset($this->resolvedPaths[$relativePath])) {
+            return $this->resolvedPaths[$relativePath];
+        }
+
+        $path = $this->basePath . '/' . ltrim($relativePath, '/');
+        $this->resolvedPaths[$relativePath] = $path;
+
+        return $path;
+    }
+
+    /**
+     * Prüft, ob ein Pfad im Projektverzeichnis existiert
+     */
+    public function pathExists(string $relativePath): bool
+    {
+        return file_exists($this->resolvePath($relativePath));
+    }
+
+    /**
+     * Konvertiert einen Namespace in einen relativen Pfad
+     */
+    public function namespaceToPath(string $namespace): ?string
+    {
+        $namespacePaths = $this->namespacePaths;
+
+        // Finde den passenden Namespace-Präfix
+        foreach ($namespacePaths as $prefix => $path) {
+            if (str_starts_with($namespace, $prefix)) {
+                $relativeNamespace = substr($namespace, strlen($prefix));
+                $relativePath = str_replace('\\', '/', $relativeNamespace);
+                return rtrim($path, '/') . '/' . $relativePath . '.php';
+            }
+        }
+
+        return null;
+    }
+
+    /**
+     * Konvertiert einen Pfad in einen Namespace
+     */
+    public function pathToNamespace(string $path): ?string
+    {
+        $namespacePaths = $this->namespacePaths;
+        $absolutePath = realpath($path);
+
+        if (!$absolutePath) {
+            return null;
+        }
+
+        // Finde den passenden Pfad-Präfix
+        foreach ($namespacePaths as $namespace => $nsPath) {
+            $realNsPath = realpath($nsPath);
+
+            if ($realNsPath && str_starts_with($absolutePath, $realNsPath)) {
+                $relativePath = substr($absolutePath, strlen($realNsPath));
+                $relativePath = rtrim(str_replace('.php', '', $relativePath), '/');
+                $relativeNamespace = str_replace('/', '\\', $relativePath);
+                return $namespace . ltrim($relativeNamespace, '\\');
+            }
+        }
+
+        return null;
+    }
+
+    /**
+     * Gibt den Pfad zum Cache-Verzeichnis zurück
+     */
+    public function getCachePath(string $path = ''): string
+    {
+        return $this->basePath . '/cache/' . ltrim($path, '/');
+    }
+
+    /**
+     * Gibt den Pfad zum Quellverzeichnis zurück
+     */
+    public function getSourcePath(string $path = ''): string
+    {
+        return $this->basePath . '/src/' . ltrim($path, '/');
+    }
+}
diff --git a/src/Framework/Core/PhpObjectExporter.php b/src/Framework/Core/PhpObjectExporter.php
index 90718655..117ed76a 100644
--- a/src/Framework/Core/PhpObjectExporter.php
+++ b/src/Framework/Core/PhpObjectExporter.php
@@ -24,7 +24,7 @@ class PhpObjectExporter
             return "new StaticRoute("
                 . var_export($value->controller, true) . ', '
                 . var_export($value->action, true) . ', '
-                . self::export($value->params, true)
+                . self::export($value->parameters, true)
                 . ")";
         }
         if ($value instanceof DynamicRoute) {
@@ -32,7 +32,7 @@ class PhpObjectExporter
                 . var_export($value->regex, true) . ', '
                 . self::export($value->parameters, true) . ', '
                 . var_export($value->controller, true) . ', '
-                . var_export($value->method, true) . ', '
+                . var_export($value->action, true) . ', '
                 . var_export($value->parameters, true)
                 . ")";
         }
diff --git a/src/Framework/Core/ProgressMeter.php b/src/Framework/Core/ProgressMeter.php
new file mode 100644
index 00000000..d7eed36b
--- /dev/null
+++ b/src/Framework/Core/ProgressMeter.php
@@ -0,0 +1,135 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Core;
+
+/**
+ * Einfacher Progressmeter für Konsolenanwendungen
+ */
+final class ProgressMeter
+{
+    private int $total;
+    private int $current = 0;
+    private int $lastPercent = 0;
+    private bool $isConsole;
+    private int $width;
+    private string $format;
+
+    /**
+     * @param int $total Gesamtanzahl der zu verarbeitenden Elemente
+     * @param int $width Breite der Fortschrittsanzeige
+     * @param string $format Format der Anzeige: 'bar' für Balken, 'percent' für Prozent, 'both' für beides
+     */
+    public function __construct(
+        int $total,
+        int $width = 50,
+        string $format = 'both'
+    ) {
+        $this->total = max(1, $total); // Verhindere Division durch Null
+        $this->width = $width;
+        $this->format = $format;
+        $this->isConsole = php_sapi_name() === 'cli';
+    }
+
+    /**
+     * Erhöht den Fortschritt um einen oder mehrere Schritte
+     */
+    public function advance(int $step = 1): void
+    {
+        $this->current += $step;
+
+        if ($this->isConsole) {
+            $percent = (int)(($this->current / $this->total) * 100);
+
+            if ($percent > $this->lastPercent || $this->current >= $this->total) {
+                $this->display();
+                $this->lastPercent = $percent;
+            }
+
+            if ($this->current >= $this->total) {
+                echo PHP_EOL;
+            }
+        }
+    }
+
+    /**
+     * Zeigt den aktuellen Fortschritt an
+     */
+    private function display(): void
+    {
+        $percent = (int)(($this->current / $this->total) * 100);
+
+        switch ($this->format) {
+            case 'bar':
+                $this->displayBar($percent);
+                break;
+            case 'percent':
+                $this->displayPercent($percent);
+                break;
+            case 'both':
+            default:
+                $this->displayBoth($percent);
+                break;
+        }
+    }
+
+    /**
+     * Zeigt einen Fortschrittsbalken an
+     */
+    private function displayBar(int $percent): void
+    {
+        $completed = (int)(($this->width * $percent) / 100);
+        $remaining = $this->width - $completed;
+
+        echo "\r[";
+        echo str_repeat("=", $completed);
+        echo str_repeat(" ", $remaining);
+        echo "] {$this->current}/{$this->total}";
+    }
+
+    /**
+     * Zeigt den Fortschritt als Prozentwert an
+     */
+    private function displayPercent(int $percent): void
+    {
+        echo "\rFortschritt: {$percent}% [{$this->current}/{$this->total}]";
+    }
+
+    /**
+     * Zeigt sowohl Balken als auch Prozentwert an
+     */
+    private function displayBoth(int $percent): void
+    {
+        $completed = (int)(($this->width * $percent) / 100);
+        $remaining = $this->width - $completed;
+
+        echo "\r[";
+        echo str_repeat("=", $completed);
+        echo str_repeat(" ", $remaining);
+        echo "] {$percent}% [{$this->current}/{$this->total}]";
+    }
+
+    /**
+     * Markiert den Fortschritt als abgeschlossen
+     */
+    public function finish(): void
+    {
+        if ($this->isConsole) {
+            $this->current = $this->total;
+            $this->display();
+            echo PHP_EOL;
+        }
+    }
+
+    /**
+     * Setzt den Fortschritt auf einen bestimmten Wert
+     */
+    public function setProgress(int $current): void
+    {
+        $this->current = max(0, min($current, $this->total));
+
+        if ($this->isConsole) {
+            $this->display();
+        }
+    }
+}
diff --git a/src/Framework/Core/Route.php b/src/Framework/Core/Route.php
index bde0f6b5..420ac68b 100644
--- a/src/Framework/Core/Route.php
+++ b/src/Framework/Core/Route.php
@@ -6,4 +6,13 @@ namespace App\Framework\Core;
 
 interface Route
 {
+    public string $controller {get;}
+
+    public string $action {get;}
+
+    public array $parameters {get;}
+
+    public string $name {get;}
+
+    public string $path {get;}
 }
diff --git a/src/Framework/Core/RouteCache.php b/src/Framework/Core/RouteCache.php
index 5f59a691..435e72f2 100644
--- a/src/Framework/Core/RouteCache.php
+++ b/src/Framework/Core/RouteCache.php
@@ -4,32 +4,40 @@ declare(strict_types=1);
 
 namespace App\Framework\Core;
 
-class RouteCache
+use App\Framework\Core\Exceptions\InvalidRouteCacheFormatException;
+use App\Framework\Core\Exceptions\RouteCacheException;
+
+final readonly class RouteCache
 {
     public function __construct(
         private string $cacheFile
     ) {
     }
 
-    public function save(array $routes)
+    public function save(array $routes): bool
     {
         $phpExport = '<?php' . PHP_EOL;
-        $phpExport .= 'use App\Framework\Core\StaticRoute;' . PHP_EOL;
-        $phpExport .= 'use App\Framework\Core\DynamicRoute;' . PHP_EOL;
+        $phpExport .= '// Automatisch generiert am ' . date('Y-m-d H:i:s') . PHP_EOL;
+        $phpExport .= 'use App\\Framework\\Core\\StaticRoute;' . PHP_EOL;
+        $phpExport .= 'use App\\Framework\\Core\\DynamicRoute;' . PHP_EOL;
         $phpExport .= 'return ' . PhpObjectExporter::export($routes) . ';' . PHP_EOL;
 
-        file_put_contents($this->cacheFile, $phpExport);
+        if (file_put_contents($this->cacheFile, $phpExport) === false) {
+            return false;
+        }
+
+        return true;
     }
 
     public function load(): array
     {
         if (! file_exists($this->cacheFile)) {
-            throw new \RuntimeException("Route cache file not found: {$this->cacheFile}");
+            throw new RouteCacheException($this->cacheFile);
         }
         $data = include $this->cacheFile;
 
         if (! is_array($data)) {
-            throw new \RuntimeException("Invalid route cache format.");
+            throw new InvalidRouteCacheFormatException($this->cacheFile);
         }
 
         return $data;
@@ -42,7 +50,8 @@ class RouteCache
             return false;
         }
 
-        // Eigenes Format prüfen? Datei-mtime prüfen? Optional!
-        return true;
+        $mtime = filemtime($this->cacheFile);
+
+        return $mtime !== false && $mtime <= $expectedMTime;
     }
 }
diff --git a/src/Framework/Core/RouteCompiler.php b/src/Framework/Core/RouteCompiler.php
index aec9dd04..260676d8 100644
--- a/src/Framework/Core/RouteCompiler.php
+++ b/src/Framework/Core/RouteCompiler.php
@@ -4,8 +4,12 @@ declare(strict_types=1);
 
 namespace App\Framework\Core;
 
-final class RouteCompiler
+use App\Framework\Router\CompiledPattern;
+use App\Framework\Router\CompiledRoutes;
+
+final readonly class RouteCompiler implements AttributeCompiler
 {
+    private array $named;
     /**
      * @param array<int, array{method: string, path: string, controller: class-string, handler: string}> $routes
      * @return array<string, array{static: array<string, array>, dynamic: array<int, array{regex: string, params: array, handler: array}>}>
@@ -13,36 +17,70 @@ final class RouteCompiler
     public function compile(array $routes): array
     {
         $compiled = [];
+        $named = [];
 
         foreach ($routes as $route) {
-            $method = strtoupper($route['http_method']);
+
+            $method = is_string($route['http_method']) ? strtoupper($route['http_method']) : $route['http_method']->value;
             $path = $route['path'];
+            $routeName = $route['name'] ?? '';
 
             $compiled[$method] ??= ['static' => [], 'dynamic' => []];
 
             if (! str_contains($path, '{')) {
                 // Statische Route
-                $compiled[$method]['static'][$path] = new StaticRoute(
+                $staticRoute =  new StaticRoute(
                     $route['class'],
                     $route['method'],
-                    $route['parameters']
+                    $route['parameters'] ?? [],
+                    $routeName,
+                    $path,
+                    $route['attributes']
                 );
+
+                $compiled[$method]['static'][$path] = $staticRoute;
+
+                if($routeName) {
+                    $named[$routeName] = $staticRoute;
+                }
+
             } else {
                 // Dynamische Route
+                $paramNames = [];
                 $regex = $this->convertPathToRegex($path, $paramNames);
-                $compiled[$method]['dynamic'][] = new DynamicRoute(
+
+                $dynamicRoute = new DynamicRoute(
                     $regex,
                     $paramNames,
                     $route['class'],
                     $route['method'],
-                    $route['parameters']
+                    $route['parameters'],
+                    [],
+                    $routeName,
+                    $path,
+                    $route['attributes']
                 );
+
+                $compiled[$method]['dynamic'][] = $dynamicRoute;
+
+                if($routeName) {
+                    $named[$routeName] = $dynamicRoute;
+                }
             }
         }
 
+        if(!isset($this->named)) {
+            $this->named = $named;
+        }
+
         return $compiled;
     }
 
+    public function compileNamedRoutes(array $routes): array
+    {
+        return $this->named;
+    }
+
     /**
      * Konvertiert zB. /user/{id}/edit → ~^/user/([^/]+)/edit$~ und gibt ['id'] als Parameternamen zurück.
      *
@@ -53,12 +91,77 @@ final class RouteCompiler
     private function convertPathToRegex(string $path, array &$paramNames): string
     {
         $paramNames = [];
-        $regex = preg_replace_callback('#\{(\w+)\}#', function ($matches) use (&$paramNames) {
+        $regex = preg_replace_callback('#\{(\w+)(\*)?}#', function ($matches) use (&$paramNames) {
             $paramNames[] = $matches[1];
 
-            return '([^/]+)';
+            // Wenn {id*} dann erlaube Slashes, aber mache es non-greedy
+            if (isset($matches[2]) && $matches[2] === '*') {
+                return '(.+?)'; // Non-greedy: matcht so wenig wie möglich
+            }
+
+            return '([^/]+)'; // Keine Slashes
         }, $path);
 
         return '~^' . $regex . '$~';
     }
+
+    public function getAttributeClass(): string
+    {
+        return Route::class;
+    }
+
+    public function compileOptimized(array $routes): CompiledRoutes
+    {
+        $compiled = $this->compile($routes);
+        $optimizedStatic = [];
+        $optimizedDynamic = [];
+
+        foreach($compiled as $method => $routes) {
+            $optimizedStatic[$method] = $routes['static'];
+
+            if(!empty($routes['dynamic'])) {
+                $optimizedDynamic[$method] = $this->createCompiledPattern($routes['dynamic']);
+            }
+        }
+
+        return new CompiledRoutes($optimizedStatic, $optimizedDynamic, $this->named);
+    }
+
+    private function createCompiledPattern(mixed $dynamicRoutes): CompiledPattern
+    {
+        $patterns = [];
+        $routeData = [];
+        $currentIndex = 1; // Nach Full Match (Index 0)
+
+        foreach($dynamicRoutes as $index => $route) {
+            $pattern = $this->stripAnchors($route->regex);
+            $patterns[] = "({$pattern})";
+
+            // Route-Gruppe Index merken
+            $routeGroupIndex = $currentIndex++;
+
+            // Parameter-Mapping KORREKT berechnen
+            $paramMap = [];
+            foreach($route->paramNames as $paramName) {
+                $paramMap[$paramName] = $currentIndex++;
+            }
+
+            $routeData[$index] = [
+                'route' => $route,
+                'paramMap' => $paramMap,
+                'routeGroupIndex' => $routeGroupIndex
+            ];
+        }
+
+        $combinedRegex = '~^(?:' . implode('|', $patterns) . ')$~';
+        return new CompiledPattern($combinedRegex, $routeData);
+    }
+
+    private function stripAnchors($regex): string
+    {
+        if (preg_match('/^~\^(.+)\$~$/', $regex, $matches)) {
+            return $matches[1];
+        }
+        return $regex;
+    }
 }
diff --git a/src/Framework/Core/RouteDiscoveryVisitor.php b/src/Framework/Core/RouteDiscoveryVisitor.php
new file mode 100644
index 00000000..ba6bb6cf
--- /dev/null
+++ b/src/Framework/Core/RouteDiscoveryVisitor.php
@@ -0,0 +1,231 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Core;
+
+use App\Framework\Attributes\Route as RouteAttribute;
+use App\Framework\Cache\Cache;
+use App\Framework\Discovery\FileVisitor;
+
+/**
+ * Visitor zum Auffinden von Routen
+ */
+final class RouteDiscoveryVisitor implements FileVisitor
+{
+    private array $routes = [];
+    private array $routesByPath = [];
+    private array $routesByController = [];
+    private bool $routesSorted = false;
+
+    public function onScanStart(): void
+    {
+        $this->routes = [];
+        $this->routesByPath = [];
+        $this->routesByController = [];
+        $this->routesSorted = false;
+    }
+
+    public function onIncrementalScanStart(): void
+    {
+        // Bei inkrementellem Scan behalten wir bestehende Routen
+        // markieren sie aber als unsortiert
+        $this->routesSorted = false;
+    }
+
+    public function onIncrementalScanComplete(): void
+    {
+        // Nach inkrementellem Scan sortieren
+        $this->sortRoutes();
+    }
+
+    public function visitClass(string $className, string $filePath): void
+    {
+        if (!class_exists($className)) {
+            return;
+        }
+
+        try {
+            $reflection = new \ReflectionClass($className);
+
+            // Prüfe, ob die Klasse überhaupt Methoden mit Route-Attributen hat
+            $hasRouteMethods = false;
+            foreach ($reflection->getMethods() as $method) {
+                if (!empty($method->getAttributes(RouteAttribute::class))) {
+                    $hasRouteMethods = true;
+                    break;
+                }
+            }
+
+            if (!$hasRouteMethods) {
+                return;
+            }
+
+            // Nur Methoden mit Route-Attribut verarbeiten
+            foreach ($reflection->getMethods() as $method) {
+                $routeAttributes = $method->getAttributes(RouteAttribute::class);
+
+                foreach ($routeAttributes as $routeAttr) {
+                    /** @var RouteAttribute $route */
+                    $route = $routeAttr->newInstance();
+
+                    $routeData = [
+                        'path' => $route->path,
+                        'method' => $route->method,
+                        'controller' => $className,
+                        'action' => $method->getName(),
+                        'middleware' => $route->middleware ?? [],
+                        'priority' => $route->priority ?? 0
+                    ];
+
+                    $this->routes[] = $routeData;
+
+                    // Erstelle Indizes für schnelleren Zugriff
+                    $path = strtolower($route->path);
+                    $httpMethod = strtoupper($route->method->value);
+                    $key = "{$httpMethod}:{$path}";
+
+                    if (!isset($this->routesByPath[$key])) {
+                        $this->routesByPath[$key] = [];
+                    }
+                    $this->routesByPath[$key][] = $routeData;
+
+                    if (!isset($this->routesByController[$className])) {
+                        $this->routesByController[$className] = [];
+                    }
+                    $this->routesByController[$className][] = $routeData;
+                }
+            }
+        } catch (\Throwable $e) {
+            error_log("Fehler beim Verarbeiten der Routen für {$className}: " . $e->getMessage());
+        }
+    }
+
+    public function onScanComplete(): void
+    {
+        // Sortiere Routen nach Priorität
+        $this->sortRoutes();
+    }
+
+    /**
+     * Sortiert die Routen nach Priorität (absteigend)
+     */
+    private function sortRoutes(): void
+    {
+        if ($this->routesSorted) {
+            return;
+        }
+
+        // Sortiere Hauptrouten-Array
+        usort($this->routes, function($a, $b) {
+            return $b['priority'] <=> $a['priority'];
+        });
+
+        // Sortiere Indizes
+        foreach ($this->routesByPath as $key => $routes) {
+            usort($this->routesByPath[$key], function($a, $b) {
+                return $b['priority'] <=> $a['priority'];
+            });
+        }
+
+        foreach ($this->routesByController as $className => $routes) {
+            usort($this->routesByController[$className], function($a, $b) {
+                return $b['priority'] <=> $a['priority'];
+            });
+        }
+
+        $this->routesSorted = true;
+    }
+
+    public function loadFromCache(Cache $cache): void
+    {
+        $cacheItem = $cache->get($this->getCacheKey());
+        if ($cacheItem->isHit) {
+            if (is_array($cacheItem->value) && isset($cacheItem->value['routes'], $cacheItem->value['byPath'], $cacheItem->value['byController'])) {
+                $this->routes = $cacheItem->value['routes'];
+                $this->routesByPath = $cacheItem->value['byPath'];
+                $this->routesByController = $cacheItem->value['byController'];
+                $this->routesSorted = true;
+            }
+        }
+    }
+
+    public function getCacheKey(): string
+    {
+        return 'routes';
+    }
+
+    public function getCacheableData(): mixed
+    {
+        // Stelle sicher, dass die Routen sortiert sind, bevor wir sie cachen
+        if (!$this->routesSorted) {
+            $this->sortRoutes();
+        }
+
+        return [
+            'routes' => $this->routes,
+            'byPath' => $this->routesByPath,
+            'byController' => $this->routesByController
+        ];
+    }
+
+    /**
+     * Gibt alle gefundenen Routen zurück
+     */
+    public function getRoutes(): array
+    {
+        if (!$this->routesSorted) {
+            $this->sortRoutes();
+        }
+        return $this->routes;
+    }
+
+    /**
+     * Findet eine Route für einen bestimmten Pfad und HTTP-Methode
+     */
+    public function findRoute(string $path, string $httpMethod): ?array
+    {
+        $path = strtolower(rtrim($path, '/'));
+        $httpMethod = strtoupper($httpMethod);
+        $key = "{$httpMethod}:{$path}";
+
+        // Direkte Übereinstimmung
+        if (isset($this->routesByPath[$key]) && !empty($this->routesByPath[$key])) {
+            return $this->routesByPath[$key][0]; // Höchste Priorität zuerst
+        }
+
+        // Prüfe auf parametrisierte Routen, wenn keine direkte Übereinstimmung
+        foreach ($this->routesByPath as $routeKey => $routes) {
+            list($routeMethod, $routePath) = explode(':', $routeKey, 2);
+
+            if ($routeMethod !== $httpMethod) {
+                continue;
+            }
+
+            // Konvertiere Route-Pfad in ein reguläres Ausdrucksmuster
+            $pattern = $this->routePathToRegex($routePath);
+            if (preg_match($pattern, $path)) {
+                return $routes[0]; // Höchste Priorität zuerst
+            }
+        }
+
+        return null;
+    }
+
+    /**
+     * Konvertiert einen Route-Pfad in ein reguläres Ausdrucksmuster
+     */
+    private function routePathToRegex(string $routePath): string
+    {
+        // Ersetze Platzhalter wie {id} durch Regex-Gruppen
+        $pattern = preg_replace('/\{([^}]+)\}/', '([^/]+)', $routePath);
+        return '/^' . str_replace('/', '\/', $pattern) . '$/';
+    }
+
+    /**
+     * Gibt alle Routen für einen bestimmten Controller zurück
+     */
+    public function getRoutesForController(string $controllerClass): array
+    {
+        return $this->routesByController[$controllerClass] ?? [];
+    }
+}
diff --git a/src/Framework/Core/RouteMapper.php b/src/Framework/Core/RouteMapper.php
index daee48d9..2eded649 100644
--- a/src/Framework/Core/RouteMapper.php
+++ b/src/Framework/Core/RouteMapper.php
@@ -20,11 +20,20 @@ final readonly class RouteMapper implements AttributeMapper
             return null;
         }
 
+        $attributes = [];
+        foreach ($reflectionTarget->getAttributes() as $attribute) {
+            if ($attribute->getName() !== Route::class) {
+                $attributes[] = $attribute->getName();
+            }
+        };
+
         return [
             'class' => $reflectionTarget->getDeclaringClass()->getName(),
             'method' => $reflectionTarget->getName(),
             'http_method' => $attributeInstance->method,
             'path' => $attributeInstance->path,
+            'name' => $attributeInstance->name,
+            'attributes' => $attributes
         ];
     }
 }
diff --git a/src/Framework/Core/StaticRoute.php b/src/Framework/Core/StaticRoute.php
index 7da378a6..62fbe4c7 100644
--- a/src/Framework/Core/StaticRoute.php
+++ b/src/Framework/Core/StaticRoute.php
@@ -4,12 +4,14 @@ declare(strict_types=1);
 
 namespace App\Framework\Core;
 
-class StaticRoute implements Route
+final readonly class StaticRoute implements Route
 {
     public function __construct(
         public string $controller,
         public string $action,
-        public array $params
-    ) {
-    }
+        public array $parameters,
+        public string $name = '',
+        public string $path = '',
+        public array $attributes = []
+    ) {}
 }
diff --git a/src/Framework/Core/VersionInfo.php b/src/Framework/Core/VersionInfo.php
new file mode 100644
index 00000000..58921090
--- /dev/null
+++ b/src/Framework/Core/VersionInfo.php
@@ -0,0 +1,54 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Core;
+
+/**
+ * Stellt Versionsinformationen für das Framework bereit.
+ */
+final readonly class VersionInfo
+{
+    /**
+     * Die aktuelle Version des Frameworks.
+     */
+    private const string VERSION = '1.0.0';
+
+    /**
+     * Gibt die aktuelle Version des Frameworks zurück.
+     */
+    public function getVersion(): string
+    {
+        return self::VERSION;
+    }
+
+    /**
+     * Prüft, ob die aktuelle Version mindestens der angegebenen Version entspricht.
+     */
+    public function isAtLeast(string $version): bool
+    {
+        return version_compare(self::VERSION, $version, '>=');
+    }
+
+    /**
+     * Prüft, ob die aktuelle Version höher als die angegebene Version ist.
+     */
+    public function isHigherThan(string $version): bool
+    {
+        return version_compare(self::VERSION, $version, '>');
+    }
+
+    /**
+     * Gibt Informationen über die Umgebung zurück.
+     *
+     * @return array{framework: string, php: string, os: string}
+     */
+    public function getEnvironmentInfo(): array
+    {
+        return [
+            'framework' => self::VERSION,
+            'php' => PHP_VERSION,
+            'os' => PHP_OS,
+        ];
+    }
+}
diff --git a/src/Framework/Core/ViewModel.php b/src/Framework/Core/ViewModel.php
new file mode 100644
index 00000000..e3bb2203
--- /dev/null
+++ b/src/Framework/Core/ViewModel.php
@@ -0,0 +1,8 @@
+<?php
+
+namespace App\Framework\Core;
+
+interface ViewModel
+{
+
+}
diff --git a/src/Framework/DI/AttributeProcessorRegistry.php b/src/Framework/DI/AttributeProcessorRegistry.php
new file mode 100644
index 00000000..ce391a03
--- /dev/null
+++ b/src/Framework/DI/AttributeProcessorRegistry.php
@@ -0,0 +1,79 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\DI;
+
+use App\Framework\Core\AttributeCompiler;
+use App\Framework\Core\AttributeMapper;
+
+final class AttributeProcessorRegistry
+{
+    /**
+     * @var AttributeMapper[]
+     */
+    private array $mappers = [];
+
+    /**
+     * @var AttributeCompiler[]
+     */
+    private array $compilers = [];
+
+    public function __construct(private readonly DefaultContainer $container)
+    {
+    }
+
+    /**
+     * Registriert einen AttributeMapper
+     */
+    public function registerMapper(string $mapperClass): self
+    {
+        $this->mappers[] = $mapperClass;
+        return $this;
+    }
+
+    /**
+     * Registriert einen AttributeCompiler
+     */
+    public function registerCompiler(string $compilerClass): self
+    {
+        $this->compilers[] = $compilerClass;
+        return $this;
+    }
+
+    /**
+     * Verarbeitet alle Attribute mit den registrierten Mappern und Compilern
+     */
+    public function processAll(array $discoveryResults): array
+    {
+        $compiledResults = [];
+        $mappedByType = [];
+
+        // Mapper-Instanzen erstellen
+        $mapperInstances = [];
+        foreach ($this->mappers as $mapperClass) {
+            $mapper = $this->container->get($mapperClass);
+            $mapperInstances[$mapper->getAttributeClass()] = $mapper;
+        }
+
+        // Compiler-Instanzen erstellen
+        $compilerInstances = [];
+        foreach ($this->compilers as $compilerClass) {
+            $compiler = $this->container->get($compilerClass);
+            $compilerInstances[$compiler->getAttributeClass()] = $compiler;
+        }
+
+        // Attribute kompilieren, für die sowohl Mapper als auch Compiler existieren
+        foreach ($discoveryResults as $attributeClass => $attributeData) {
+            if (isset($mapperInstances[$attributeClass]) && isset($compilerInstances[$attributeClass])) {
+                // Wenn ein Compiler vorhanden ist, verwenden wir ihn zur Kompilierung
+                $compiledResults[$attributeClass] = $compilerInstances[$attributeClass]->compile($attributeData);
+            } elseif (isset($mapperInstances[$attributeClass])) {
+                // Ohne Compiler geben wir die gemappten Daten direkt zurück
+                $compiledResults[$attributeClass] = $attributeData;
+            }
+        }
+
+        return $compiledResults;
+    }
+
+}
diff --git a/src/Framework/DI/BindingRegistry.php b/src/Framework/DI/BindingRegistry.php
new file mode 100644
index 00000000..e8ba8851
--- /dev/null
+++ b/src/Framework/DI/BindingRegistry.php
@@ -0,0 +1,36 @@
+<?php
+
+namespace App\Framework\DI;
+
+/**
+ * Verwaltet alle Service-Bindings
+ */
+final class BindingRegistry
+{
+    private array $bindings = [];
+
+    public function bind(string $abstract, callable|string|object $concrete): void
+    {
+        $this->bindings[$abstract] = $concrete;
+    }
+
+    public function hasBinding(string $abstract): bool
+    {
+        return isset($this->bindings[$abstract]);
+    }
+
+    public function getBinding(string $abstract): callable|string|object|null
+    {
+        return $this->bindings[$abstract] ?? null;
+    }
+
+    public function forget(string $abstract): void
+    {
+        unset($this->bindings[$abstract]);
+    }
+
+    public function getAllBindings(): array
+    {
+        return array_keys($this->bindings);
+    }
+}
diff --git a/src/Framework/DI/Container.php b/src/Framework/DI/Container.php
index d9bf2334..a5ec0305 100644
--- a/src/Framework/DI/Container.php
+++ b/src/Framework/DI/Container.php
@@ -1,47 +1,20 @@
 <?php
 
-declare(strict_types=1);
-
 namespace App\Framework\DI;
 
-use App\Framework\Attributes\Singleton;
-
-class Container
+interface Container
 {
-    private array $singletons = [];
+    public MethodInvoker $invoker {get;}
 
-    public function __construct(private array $definitions)
-    {
-
-    }
-
-    public function get(string $class): object
-    {
-        if (isset($this->singletons[$class])) {
-            return $this->singletons[$class];
-        }
-
-        $reflection = new \ReflectionClass($class);
-
-        $constructor = $reflection->getConstructor();
-        $dependencies = [];
-
-        if ($constructor !== null) {
-            foreach ($constructor->getParameters() as $param) {
-                $type = $param->getType();
-                if (!$type || $type->isBuiltin()) {
-                    throw new \RuntimeException("Cannot resolve parameter {$param->getName()}");
-                }
-                $dependencies[] = $this->get($type->getName());
-            }
-        }
-
-        $instance = $reflection->newInstanceArgs($dependencies);
-
-        if ($reflection->getAttributes(Singleton::class)) {
-            $this->singletons[$class] = $instance;
-        }
-
-        return $instance;
-    }
+    /**
+     * @template T of object
+     * @param class-string<T> $class
+     * @return T
+     */
+    public function get(string $class): object;
+    public function has(string $class): bool;
+    public function bind(string $abstract, callable|string|object $concrete): void;
+    public function singleton(string $abstract, callable|string|object $concrete): void;
+    public function instance(string $abstract, object $instance): void;
+    public function forget(string $class): void;
 }
diff --git a/src/Framework/DI/ContainerCompiler.php b/src/Framework/DI/ContainerCompiler.php
new file mode 100644
index 00000000..ef1f6290
--- /dev/null
+++ b/src/Framework/DI/ContainerCompiler.php
@@ -0,0 +1,142 @@
+<?php
+
+namespace App\Framework\DI;
+
+class ContainerCompiler
+{
+public function compile(DefaultContainer $container, array $services, string $outputFile): void
+{
+        $code = "<?php\n\nnamespace App\\Framework\\DI;\n\nclass CompiledContainer extends Container\n{\n";
+
+        // get()-Methode überschreiben
+        $code .= "    public function get(string \$class): object\n     {\n";
+        $code .= "        // Singleton- und Instanz-Prüfung vom Basiscontainer\n";
+        $code .= "        if (isset(\$this->singletons[\$class])) {\n";
+        $code .= "            return \$this->singletons[\$class];\n";
+        $code .= "        }\n\n";
+        $code .= "        if (isset(\$this->instances[\$class])) {\n";
+        $code .= "            return \$this->instances[\$class];\n";
+        $code .= "        }\n\n";
+
+        // Switch-Statement für bekannte Services
+        $code .= "        // Optimierte Factory-Methoden für bekannte Services\n";
+        $code .= "        switch (\$class) {\n";
+
+        foreach ($services as $service) {
+            $code .= "            case \\{$service}::class:\n";
+            $code .= "                return \$this->create" . $this->getServiceMethodName($service) . "();\n";
+        }
+
+        $code .= "            default:\n";
+        $code .= "                // Fallback auf Standard-Container\n";
+        $code .= "                return parent::get(\$class);\n";
+        $code .= "        }\n";
+        $code .= "    }\n\n";
+
+        // Factory-Methoden für jeden bekannten Service
+        foreach ($services as $service) {
+            $code .= $this->generateFactoryMethod($service, $container);
+        }
+
+        $code .= "}\n";
+
+        file_put_contents($outputFile, $code);
+    }
+
+    private function getServiceMethodName(string $service): string
+    {
+        // Erzeugt einen methodenkompatiblen Namen aus dem Klassennamen
+        $parts = explode('\\', $service);
+        return end($parts);
+    }
+
+    private function generateFactoryMethod(string $service, DefaultContainer $container): string
+    {
+        // Analysiert den Service und seine Abhängigkeiten
+        $reflection = new \ReflectionClass($service);
+        $constructor = $reflection->getConstructor();
+
+        $methodName = 'create' . $this->getServiceMethodName($service);
+        $code = "    private function {$methodName}(): \\{$service}\n    {\n";
+
+        // Dependency-Analyse und optimierter Instantiierungs-Code
+        if ($constructor) {
+            $params = [];
+            foreach ($constructor->getParameters() as $param) {
+                $paramType = $param->getType();
+                if ($paramType instanceof \ReflectionNamedType && !$paramType->isBuiltin()) {
+                    $typeName = $paramType->getName();
+                    $params[] = "\$this->get(\\{$typeName}::class)";
+                } elseif ($param->isDefaultValueAvailable()) {
+                    $default = var_export($param->getDefaultValue(), true);
+                    $params[] = $default;
+                } elseif ($paramType instanceof \ReflectionNamedType && $paramType->allowsNull()) {
+                    $params[] = 'null';
+                } else {
+                    // Nicht auflösbar, Fallback
+                    $paramName = $param->getName();
+                    $params[] = "/* Parameter '{$paramName}' konnte nicht aufgelöst werden */";
+                }
+            }
+
+            $paramsStr = implode(', ', $params);
+            $code .= "        return new \\{$service}({$paramsStr});\n";
+        } else {
+            $code .= "        return new \\{$service}();\n";
+        }
+
+        $code .= "    }\n\n";
+
+        return $code;
+    }
+
+
+    // Neue Methode zur Abhängigkeitsanalyse hinzufügen
+    public function analyzeDependencies(DefaultContainer $container, array $services): array
+    {
+        $dependencies = [];
+        $analyzedServices = [];
+
+        // Rekursive Analyse von Service-Abhängigkeiten
+        foreach ($services as $service) {
+            $this->analyzeServiceDependencies($service, $dependencies, $analyzedServices);
+        }
+
+        return array_unique(array_merge($services, array_keys($dependencies)));
+    }
+
+    private function analyzeServiceDependencies(
+        string $service,
+        array &$dependencies,
+        array &$analyzedServices
+    ): void {
+        // Vermeidung von Zyklen
+        if (isset($analyzedServices[$service])) {
+            return;
+        }
+
+        $analyzedServices[$service] = true;
+
+        try {
+            $reflection = new \ReflectionClass($service);
+            $constructor = $reflection->getConstructor();
+
+            if ($constructor) {
+                foreach ($constructor->getParameters() as $param) {
+                    $type = $param->getType();
+
+                    if ($type instanceof \ReflectionNamedType && !$type->isBuiltin()) {
+                        $typeName = $type->getName();
+                        $dependencies[$typeName] = true;
+
+                        // Rekursive Analyse der Abhängigkeit
+                        $this->analyzeServiceDependencies($typeName, $dependencies, $analyzedServices);
+                    }
+                }
+            }
+        } catch (\ReflectionException $e) {
+            // Fehlerbehandlung
+        }
+    }
+
+}
diff --git a/src/Framework/DI/DOKUMENTATION.md b/src/Framework/DI/DOKUMENTATION.md
new file mode 100644
index 00000000..72799e1f
--- /dev/null
+++ b/src/Framework/DI/DOKUMENTATION.md
@@ -0,0 +1,90 @@
+# Dependency Injection Modul
+
+## Übersicht
+
+Das DI-Modul implementiert ein Dependency-Injection-Container-System, das die automatische Auflösung und Verwaltung von Abhängigkeiten ermöglicht.
+
+## Hauptkomponenten
+
+### Container
+
+Der zentrale Service-Container, der Instanzen erstellt und verwaltet.
+
+**Hauptfunktionen:**
+- Service-Erstellung und -Auflösung
+- Singleton-Verwaltung
+- Rekursive Abhängigkeitsauflösung
+
+### Initializer-Attribut
+
+Das `#[Initializer]`-Attribut kennzeichnet Klassen, die Services im Container registrieren können.
+
+**Beispiel:**
+```php
+readonly class AnalyticsInitializer
+{
+    #[Initializer]
+    public function __invoke(Container $container): Analytics
+    {
+        // Service erstellen und konfigurieren
+        return $analytics;
+    }
+}
+```
+
+## Verwendung
+
+### Service definieren
+
+```php
+// Service-Interface
+interface MyServiceInterface
+{
+    public function doSomething(): void;
+}
+
+// Konkrete Implementierung
+class MyService implements MyServiceInterface
+{
+    public function doSomething(): void
+    {
+        // Implementierung
+    }
+}
+```
+
+### Service registrieren
+
+```php
+
+class MyServiceInitializer
+{
+    #[Initializer]
+    public function __invoke(Container $container): MyServiceInterface
+    {
+        return new MyService();
+    }
+}
+```
+
+### Service verwenden
+
+```php
+class MyController
+{
+    public function __construct(
+        private readonly MyServiceInterface $myService
+    ) {}
+
+    public function action(): void
+    {
+        $this->myService->doSomething();
+    }
+}
+```
+
+## Prinzipien
+
+- **Automatische Auflösung**: Abhängigkeiten werden anhand von Typ-Hints automatisch aufgelöst
+- **Lazy Loading**: Services werden erst erstellt, wenn sie benötigt werden
+- **Singleton-Modus**: Standardmäßig werden Services als Singletons verwaltet
diff --git a/src/Framework/DI/DefaultContainer.php b/src/Framework/DI/DefaultContainer.php
new file mode 100644
index 00000000..16b9fa80
--- /dev/null
+++ b/src/Framework/DI/DefaultContainer.php
@@ -0,0 +1,177 @@
+<?php
+
+namespace App\Framework\DI;
+
+use App\Framework\DI\Exceptions\CyclicDependencyException;
+use App\Framework\DI\Exceptions\LazyLoadingException;
+use App\Framework\Reflection\CachedReflectionProvider;
+use App\Framework\Reflection\ReflectionProvider;
+
+use Throwable;
+
+final class DefaultContainer implements Container
+{
+    private array $resolving = [];
+    private readonly DependencyResolver $dependencyResolver;
+    private readonly SingletonDetector $singletonDetector;
+    private readonly LazyInstantiator $lazyInstantiator;
+    public readonly MethodInvoker $invoker;
+
+    public function __construct(
+        private readonly InstanceRegistry $instances = new InstanceRegistry(),
+        private readonly BindingRegistry $bindings = new BindingRegistry(),
+        private readonly ReflectionProvider $reflectionProvider = new CachedReflectionProvider(),
+    ){
+        $this->dependencyResolver = new DependencyResolver($this->reflectionProvider, $this);
+        $this->singletonDetector = new SingletonDetector($this->reflectionProvider, $this->instances);
+        $this->lazyInstantiator = new LazyInstantiator(
+            $this->reflectionProvider,
+            $this->createInstance(...)
+        );
+        $this->invoker = new MethodInvoker($this, $this->reflectionProvider);
+
+        $this->registerSelf();
+    }
+
+    public function bind(string $abstract, callable|string|object $concrete): void
+    {
+        $this->bindings->bind($abstract, $concrete);
+        $this->clearCaches($abstract);
+    }
+
+    public function singleton(string $abstract, callable|string|object $concrete): void
+    {
+        $this->bind($abstract, $concrete);
+        $this->instances->markAsSingleton($abstract);
+    }
+
+    public function instance(string $abstract, object $instance): void
+    {
+        $this->instances->setInstance($abstract, $instance);
+    }
+
+    /**
+     * @template T of object
+     * @param class-string<T> $class
+     * @return T
+     */
+    public function get(string $class): object
+    {
+        // Bereits instanziierte Objekte zurückgeben
+        if ($this->instances->hasSingleton($class)) {
+            return $this->instances->getSingleton($class);
+        }
+
+        if ($this->instances->hasInstance($class)) {
+            return $this->instances->getInstance($class);
+        }
+
+        // Lazy Loading versuchen
+        if ($this->lazyInstantiator->canUseLazyLoading($class, $this->instances)) {
+            try {
+                return $this->lazyInstantiator->createLazyInstance($class);
+            } catch (Throwable $e) {
+                if (!$e instanceof LazyLoadingException) {
+                    throw $e;
+                }
+            }
+        }
+
+        return $this->createInstance($class);
+    }
+
+    private function createInstance(string $class): object
+    {
+        if (in_array($class, $this->resolving, true)) {
+            throw new CyclicDependencyException(
+                dependencyChain: $this->resolving,
+                class: $class
+            );
+        }
+
+        $this->resolving[] = $class;
+
+        try {
+            $instance = $this->buildInstance($class);
+
+            if ($this->singletonDetector->isSingleton($class)) {
+                $this->instances->setSingleton($class, $instance);
+            } else {
+                $this->instances->setInstance($class, $instance);
+            }
+
+            return $instance;
+        } finally {
+            array_pop($this->resolving);
+        }
+    }
+
+    private function buildInstance(string $class): object
+    {
+        if ($this->bindings->hasBinding($class)) {
+            return $this->resolveBinding($class, $this->bindings->getBinding($class));
+        }
+
+        $reflection = $this->reflectionProvider->getClass($class);
+        $dependencies = $this->dependencyResolver->resolveDependencies($class);
+
+        return $reflection->newInstanceArgs($dependencies);
+    }
+
+    private function resolveBinding(string $class, callable|string|object $concrete): object
+    {
+        return match (true) {
+            is_callable($concrete) => $concrete($this),
+            is_string($concrete) => $this->get($concrete),
+            default => $concrete
+        };
+    }
+
+    public function has(string $class): bool
+    {
+        return $this->instances->hasSingleton($class)
+            || $this->instances->hasInstance($class)
+            || $this->bindings->hasBinding($class)
+            || class_exists($class);
+    }
+
+    public function forget(string $class): void
+    {
+        $this->instances->forget($class);
+        $this->bindings->forget($class);
+        $this->clearCaches($class);
+    }
+
+    public function flush(): void
+    {
+        $this->instances->flush();
+        $this->reflectionProvider->flush();
+        $this->dependencyResolver->flushCache();
+        $this->lazyInstantiator->flushFactories();
+
+        // Container selbst wieder registrieren
+        $this->registerSelf();
+    }
+
+    public function getRegisteredServices(): array
+    {
+        return array_merge(
+            $this->instances->getAllRegistered(),
+            $this->bindings->getAllBindings()
+        );
+    }
+
+    private function clearCaches(string $class): void
+    {
+        $this->reflectionProvider->forget($class);
+        $this->dependencyResolver->clearCache($class);
+        $this->lazyInstantiator->forgetFactory($class);
+    }
+
+    private function registerSelf():void
+    {
+        $this->instances->setSingleton(self::class, $this);
+        $this->instances->setSingleton(DefaultContainer::class, $this);
+        $this->instances->setSingleton(Container::class, $this);
+    }
+}
diff --git a/src/Framework/DI/DependencyResolver.php b/src/Framework/DI/DependencyResolver.php
new file mode 100644
index 00000000..f8c6ade7
--- /dev/null
+++ b/src/Framework/DI/DependencyResolver.php
@@ -0,0 +1,110 @@
+<?php
+
+namespace App\Framework\DI;
+
+use App\Framework\DI\Exceptions\ParameterResolutionException;
+use App\Framework\Reflection\ReflectionProvider;
+use ReflectionNamedType;
+use ReflectionParameter;
+
+/**
+ * Löst Constructor-Abhängigkeiten auf
+ */
+final class DependencyResolver
+{
+    private array $constructorCache = [];
+
+    public function __construct(
+        private readonly ReflectionProvider $reflectionProvider,
+        private readonly Container $container
+    ) {}
+
+    public function resolveDependencies(string $class): array
+    {
+        $reflection = $this->reflectionProvider->getClass($class);
+        $constructor = $reflection->getConstructor();
+
+        if ($constructor === null) {
+            return [];
+        }
+
+        if (isset($this->constructorCache[$class])) {
+            return $this->resolveFromCache($class);
+        }
+
+        $dependencies = [];
+        $cacheInfo = [];
+
+        foreach ($constructor->getParameters() as $param) {
+            $dependency = $this->resolveParameter($param, $class);
+            $dependencies[] = $dependency['value'];
+            $cacheInfo[] = $dependency['cache'];
+        }
+
+        // Nur cacheable Parameter cachen
+        if (!in_array(false, array_column($cacheInfo, 'cacheable'), true)) {
+            $this->constructorCache[$class] = $cacheInfo;
+        }
+
+        return $dependencies;
+    }
+
+    private function resolveParameter(ReflectionParameter $param, string $class): array
+    {
+        $type = $param->getType();
+
+        if ($param->isDefaultValueAvailable()) {
+            return [
+                'value' => $param->getDefaultValue(),
+                'cache' => ['type' => 'default', 'value' => $param->getDefaultValue(), 'cacheable' => true]
+            ];
+        }
+
+        if ($type instanceof ReflectionNamedType && $type->allowsNull()) {
+            return [
+                'value' => null,
+                'cache' => ['type' => 'null', 'cacheable' => true]
+            ];
+        }
+
+        if (!$type || $type->isBuiltin()) {
+            throw new ParameterResolutionException(
+                paramName: $param->getName(),
+                class: $class,
+                dependencyChain: [] // Wird vom Container gesetzt
+            );
+        }
+
+        $typeName = $type->getName();
+        return [
+            'value' => $this->container->get($typeName),
+            'cache' => ['type' => 'dependency', 'class' => $typeName, 'cacheable' => false]
+        ];
+    }
+
+    private function resolveFromCache(string $class): array
+    {
+        $cacheInfo = $this->constructorCache[$class];
+        $dependencies = [];
+
+        foreach ($cacheInfo as $info) {
+            $dependencies[] = match ($info['type']) {
+                'default' => $info['value'],
+                'null' => null,
+                'dependency' => $this->container->get($info['class']),
+            };
+        }
+
+        return $dependencies;
+    }
+
+    public function clearCache(string $class): void
+    {
+        unset($this->constructorCache[$class]);
+    }
+
+    public function flushCache(): void
+    {
+        $this->constructorCache = [];
+    }
+}
diff --git a/src/Framework/DI/Exceptions/CyclicDependencyException.php b/src/Framework/DI/Exceptions/CyclicDependencyException.php
new file mode 100644
index 00000000..a8f8cd88
--- /dev/null
+++ b/src/Framework/DI/Exceptions/CyclicDependencyException.php
@@ -0,0 +1,27 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\DI\Exceptions;
+
+use App\Framework\Exception\FrameworkException;
+
+final class CyclicDependencyException extends FrameworkException
+{
+    public function __construct(
+        array $dependencyChain,
+        string $class,
+        int $code = 0,
+        ?\Throwable $previous = null
+    ) {
+        parent::__construct(
+            message: 'Zyklische Abhängigkeit entdeckt: ' . implode(' -> ', $dependencyChain) . " -> $class",
+            code: $code,
+            previous: $previous,
+            context: [
+                'dependencyChain' => $dependencyChain,
+                'class' => $class
+            ]
+        );
+    }
+}
diff --git a/src/Framework/DI/Exceptions/LazyLoadingException.php b/src/Framework/DI/Exceptions/LazyLoadingException.php
new file mode 100644
index 00000000..1fa75207
--- /dev/null
+++ b/src/Framework/DI/Exceptions/LazyLoadingException.php
@@ -0,0 +1,22 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\DI\Exceptions;
+
+use App\Framework\Exception\FrameworkException;
+
+final class LazyLoadingException extends FrameworkException
+{
+    public function __construct(
+        string $class,
+        int $code = 0,
+        ?\Throwable $previous = null
+    ) {
+        parent::__construct(
+            message: "Lazy Loading wird für die Klasse $class nicht unterstützt",
+            code: $code,
+            previous: $previous
+        );
+    }
+}
diff --git a/src/Framework/DI/Exceptions/ParameterResolutionException.php b/src/Framework/DI/Exceptions/ParameterResolutionException.php
new file mode 100644
index 00000000..1b640ae2
--- /dev/null
+++ b/src/Framework/DI/Exceptions/ParameterResolutionException.php
@@ -0,0 +1,29 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\DI\Exceptions;
+
+use App\Framework\Exception\FrameworkException;
+
+final class ParameterResolutionException extends FrameworkException
+{
+    public function __construct(
+        string $paramName,
+        string $class,
+        array $dependencyChain,
+        int $code = 0,
+        ?\Throwable $previous = null
+    ) {
+        parent::__construct(
+            message: "Cannot resolve parameter {$paramName} in $class. Dependency chain: " . implode(' -> ', $dependencyChain),
+            code: $code,
+            previous: $previous,
+            context: [
+                'paramName' => $paramName,
+                'class' => $class,
+                'dependencyChain' => $dependencyChain
+            ]
+        );
+    }
+}
diff --git a/src/Framework/DI/Initializer.php b/src/Framework/DI/Initializer.php
new file mode 100644
index 00000000..9bcf82a4
--- /dev/null
+++ b/src/Framework/DI/Initializer.php
@@ -0,0 +1,8 @@
+<?php
+
+namespace App\Framework\DI;
+
+#[\Attribute(\Attribute::TARGET_METHOD)]
+final class Initializer
+{
+}
diff --git a/src/Framework/DI/InitializerMapper.php b/src/Framework/DI/InitializerMapper.php
new file mode 100644
index 00000000..d6cd52ff
--- /dev/null
+++ b/src/Framework/DI/InitializerMapper.php
@@ -0,0 +1,23 @@
+<?php
+
+namespace App\Framework\DI;
+
+use App\Framework\Core\AttributeMapper;
+
+final readonly class InitializerMapper implements AttributeMapper
+{
+    public function getAttributeClass(): string
+    {
+        return Initializer::class;
+    }
+
+    public function map(object $reflectionTarget, object $attributeInstance): ?array
+    {
+        return [
+            'class' => $reflectionTarget->getDeclaringClass()->getName(),
+            'return' => $reflectionTarget->getReturnType()->getName(),
+            'method' => $reflectionTarget->getName(),
+            #'path' => $attributeInstance->path,
+        ];
+    }
+}
diff --git a/src/Framework/DI/InstanceRegistry.php b/src/Framework/DI/InstanceRegistry.php
new file mode 100644
index 00000000..bd6bd4d6
--- /dev/null
+++ b/src/Framework/DI/InstanceRegistry.php
@@ -0,0 +1,66 @@
+<?php
+
+namespace App\Framework\DI;
+
+/**
+ * Verwaltet alle instanziierten Objekte und Singletons
+ */
+final class InstanceRegistry
+{
+    private array $singletons = [];
+    private array $instances = [];
+
+    public function getSingleton(string $class): ?object
+    {
+        return $this->singletons[$class] ?? null;
+    }
+
+    public function hasSingleton(string $class): bool
+    {
+        return isset($this->singletons[$class]) && $this->singletons[$class] !== null;
+    }
+
+    public function setSingleton(string $class, object $instance): void
+    {
+        $this->singletons[$class] = $instance;
+    }
+
+    public function markAsSingleton(string $class): void
+    {
+        $this->singletons[$class] = null;
+    }
+
+    public function getInstance(string $class): ?object
+    {
+        return $this->instances[$class] ?? null;
+    }
+
+    public function hasInstance(string $class): bool
+    {
+        return isset($this->instances[$class]);
+    }
+
+    public function setInstance(string $class, object $instance): void
+    {
+        $this->instances[$class] = $instance;
+    }
+
+    public function forget(string $class): void
+    {
+        unset($this->instances[$class], $this->singletons[$class]);
+    }
+
+    public function flush(): void
+    {
+        $this->instances = [];
+        $this->singletons = [];
+    }
+
+    public function getAllRegistered(): array
+    {
+        return array_merge(
+            array_keys($this->singletons),
+            array_keys($this->instances)
+        );
+    }
+}
diff --git a/src/Framework/DI/LazyInstantiator.php b/src/Framework/DI/LazyInstantiator.php
new file mode 100644
index 00000000..01c79475
--- /dev/null
+++ b/src/Framework/DI/LazyInstantiator.php
@@ -0,0 +1,56 @@
+<?php
+
+namespace App\Framework\DI;
+
+use App\Framework\DI\Exceptions\LazyLoadingException;
+use App\Framework\Reflection\ReflectionProvider;
+use Closure;
+
+/**
+ * Behandelt Lazy Loading von Objekten
+ */
+final class LazyInstantiator
+{
+    private array $factories = [];
+
+    public function __construct(
+        private readonly ReflectionProvider $reflectionProvider,
+        private readonly Closure $instanceCreator
+    ) {}
+
+    public function canUseLazyLoading(string $class, InstanceRegistry $registry): bool
+    {
+        return !$registry->hasSingleton($class);
+    }
+
+    public function createLazyInstance(string $class): object
+    {
+        $reflection = $this->reflectionProvider->getClass($class);
+
+        if (!isset($this->factories[$class])) {
+            $this->factories[$class] = fn() => ($this->instanceCreator)($class);
+        }
+
+        $factory = $this->factories[$class];
+
+        if (method_exists($reflection, 'getLazyGhost')) {
+            return $reflection->getLazyGhost($factory);
+        }
+
+        if (method_exists($reflection, 'getLazyProxy')) {
+            return $reflection->getLazyProxy($factory);
+        }
+
+        throw new LazyLoadingException("Lazy loading not supported for class: {$class}");
+    }
+
+    public function forgetFactory(string $class): void
+    {
+        unset($this->factories[$class]);
+    }
+
+    public function flushFactories(): void
+    {
+        $this->factories = [];
+    }
+}
diff --git a/src/Framework/DI/MethodInvoker.php b/src/Framework/DI/MethodInvoker.php
new file mode 100644
index 00000000..6343ae67
--- /dev/null
+++ b/src/Framework/DI/MethodInvoker.php
@@ -0,0 +1,127 @@
+<?php
+
+namespace App\Framework\DI;
+
+use App\Framework\Reflection\ReflectionProvider;
+use ReflectionMethod;
+use ReflectionNamedType;
+
+/**
+ * Führt Methoden auf beliebigen Klassen mit automatischer Dependency Injection aus
+ */
+final readonly class MethodInvoker
+{
+    public function __construct(
+        private Container       $container,
+        private ReflectionProvider $reflectionCache
+    ) {}
+
+    /**
+     * Führt eine Methode auf einer Klasse aus und löst alle Parameter automatisch auf
+     */
+    public function invoke(string $className, string $methodName, array $overrides = []): mixed
+    {
+        $instance = $this->container->get($className);
+        return $this->invokeOn($instance, $methodName, $overrides);
+    }
+
+    /**
+     * Führt eine Methode auf einer bereits existierenden Instanz aus
+     */
+    public function invokeOn(object $instance, string $methodName, array $overrides = []): mixed
+    {
+        $reflection = $this->reflectionCache->getClass($instance::class);
+
+        if (!$reflection->hasMethod($methodName)) {
+            throw new \InvalidArgumentException(
+                "Method $methodName does not exist on class $instance::class"
+            );
+        }
+
+        $method = $this->reflectionCache->getMethod($instance::class, $methodName);
+
+        if (!$method->isPublic()) {
+            throw new \InvalidArgumentException(
+                "Method $methodName on class $instance::class is not public"
+            );
+        }
+
+        $parameters = $this->resolveMethodParameters($method, $overrides);
+
+        return $method->invokeArgs($instance, $parameters);
+    }
+
+    /**
+     * Führt eine statische Methode aus
+     */
+    public function invokeStatic(string $className, string $methodName, array $overrides = []): mixed
+    {
+        $reflection = $this->reflectionCache->getClass($className);
+
+        if (!$reflection->hasMethod($methodName)) {
+            throw new \InvalidArgumentException(
+                "Method '{$methodName}' does not exist on class '{$className}'"
+            );
+        }
+
+        $method = $this->reflectionCache->getMethod($className, $methodName);
+
+        if (!$method->isStatic()) {
+            throw new \InvalidArgumentException(
+                "Method '{$methodName}' on class '{$className}' is not static"
+            );
+        }
+
+        $parameters = $this->resolveMethodParameters($method, $overrides);
+
+        return $method->invokeArgs(null, $parameters);
+    }
+
+    /**
+     * Löst alle Parameter einer Methode auf
+     */
+    private function resolveMethodParameters(ReflectionMethod $method, array $overrides): array
+    {
+        $parameters = [];
+
+        foreach ($method->getParameters() as $param) {
+            $paramName = $param->getName();
+
+            // Override-Werte haben Priorität
+            if (array_key_exists($paramName, $overrides)) {
+                $parameters[] = $overrides[$paramName];
+                continue;
+            }
+
+            // Type-based injection
+            $type = $param->getType();
+
+            if ($type instanceof ReflectionNamedType && !$type->isBuiltin()) {
+                $typeName = $type->getName();
+
+                if ($this->container->has($typeName)) {
+                    $parameters[] = $this->container->get($typeName);
+                    continue;
+                }
+            }
+
+            // Default-Werte verwenden
+            if ($param->isDefaultValueAvailable()) {
+                $parameters[] = $param->getDefaultValue();
+                continue;
+            }
+
+            // Nullable Parameter
+            if ($type && $type->allowsNull()) {
+                $parameters[] = null;
+                continue;
+            }
+
+            throw new \InvalidArgumentException(
+                "Cannot resolve parameter '{$paramName}' for method '{$method->getName()}' on class '{$method->getDeclaringClass()->getName()}'"
+            );
+        }
+
+        return $parameters;
+    }
+}
diff --git a/src/Framework/DI/ReflectionCache.php b/src/Framework/DI/ReflectionCache.php
new file mode 100644
index 00000000..32a55ee9
--- /dev/null
+++ b/src/Framework/DI/ReflectionCache.php
@@ -0,0 +1,64 @@
+<?php
+
+namespace App\Framework\DI;
+
+use ReflectionClass;
+use ReflectionMethod;
+
+/**
+ * Cache für ReflectionClass-Instanzen
+ */
+final class ReflectionCache
+{
+    private array $classCache = [];
+    private array $methodCache = [];
+
+    private array $parameterCache = [];
+
+    public function get(string $class): ReflectionClass
+    {
+        return $this->classCache[$class] ??= new ReflectionClass($class);
+    }
+
+    public function getMethod(string $class, string $method): ReflectionMethod
+    {
+        $key = "{$class}::{$method}";
+        return $this->methodCache[$key] ??= $this->get($class)->getMethod($method);
+    }
+
+    public function getMethodParameters(string $class, string $method): array
+    {
+        $key = "{$class}::{$method}::params";
+        return $this->parameterCache[$key] ??= $this->getMethod($class, $method)->getParameters();
+    }
+
+    public function forget(string $class): void
+    {
+        unset($this->classCache[$class]);
+
+        // Alle Methods dieser Klasse aus dem Cache entfernen
+        $this->methodCache = array_filter(
+            $this->methodCache,
+            fn($key) => !str_starts_with($key, $class . '::'),
+            ARRAY_FILTER_USE_KEY
+        );
+
+        $this->parameterCache = array_filter(
+            $this->parameterCache,
+            fn($key) => !str_starts_with($key, $class . '::'),
+            ARRAY_FILTER_USE_KEY
+        );
+    }
+
+    public function forgetMethod(string $class, string $method): void
+    {
+        unset($this->methodCache["{$class}::{$method}"]);
+    }
+
+    public function flush(): void
+    {
+        $this->classCache = [];
+        $this->methodCache = [];
+        $this->parameterCache = [];
+    }
+}
diff --git a/src/Framework/DI/SingletonDetector.php b/src/Framework/DI/SingletonDetector.php
new file mode 100644
index 00000000..c8b0bb8a
--- /dev/null
+++ b/src/Framework/DI/SingletonDetector.php
@@ -0,0 +1,27 @@
+<?php
+
+namespace App\Framework\DI;
+
+use App\Framework\Attributes\Singleton;
+use App\Framework\Reflection\ReflectionProvider;
+
+/**
+ * Erkennt ob eine Klasse als Singleton markiert ist
+ */
+final readonly class SingletonDetector
+{
+    public function __construct(
+        private ReflectionProvider $reflectionProvider,
+        private InstanceRegistry $instanceRegistry
+    ) {}
+
+    public function isSingleton(string $class): bool
+    {
+        if ($this->instanceRegistry->hasSingleton($class)) {
+            return true;
+        }
+
+        $reflection = $this->reflectionProvider->getClass($class);
+        return count($reflection->getAttributes(Singleton::class)) > 0;
+    }
+}
diff --git a/src/Framework/Database/Attributes/Column.php b/src/Framework/Database/Attributes/Column.php
new file mode 100644
index 00000000..1bd82eed
--- /dev/null
+++ b/src/Framework/Database/Attributes/Column.php
@@ -0,0 +1,17 @@
+<?php
+
+namespace App\Framework\Database\Attributes;
+
+use Attribute;
+
+#[Attribute(Attribute::TARGET_PROPERTY)]
+class Column
+{
+    public function __construct(
+        public ?string $name = null,
+        public ?string $type = null,
+        public bool $primary = false,
+        public bool $autoIncrement = false,
+        public bool $nullable = false
+    ) {}
+}
diff --git a/src/Framework/Database/Attributes/Entity.php b/src/Framework/Database/Attributes/Entity.php
new file mode 100644
index 00000000..13c09031
--- /dev/null
+++ b/src/Framework/Database/Attributes/Entity.php
@@ -0,0 +1,14 @@
+<?php
+
+namespace App\Framework\Database\Attributes;
+
+use Attribute;
+
+#[Attribute(Attribute::TARGET_CLASS)]
+class Entity
+{
+    public function __construct(
+        public ?string $tableName = null,
+        public string $idColumn = 'id'
+    ) {}
+}
diff --git a/src/Framework/Database/Attributes/Type.php b/src/Framework/Database/Attributes/Type.php
new file mode 100644
index 00000000..ee1ab58c
--- /dev/null
+++ b/src/Framework/Database/Attributes/Type.php
@@ -0,0 +1,18 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Database\Attributes;
+
+use Attribute;
+
+#[Attribute(Attribute::TARGET_PROPERTY)]
+final readonly class Type
+{
+    public function __construct(
+        public string $targetClass,
+        public ?string $foreignKey = null,
+        public ?string $localKey = null,
+        public string $type = 'hasMany'
+    ) {}
+}
diff --git a/src/Framework/Database/Cache/CacheAdapterStrategy.php b/src/Framework/Database/Cache/CacheAdapterStrategy.php
new file mode 100644
index 00000000..b6930450
--- /dev/null
+++ b/src/Framework/Database/Cache/CacheAdapterStrategy.php
@@ -0,0 +1,208 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Database\Cache;
+
+use App\Framework\Cache\Cache;
+
+final class CacheAdapterStrategy implements CacheStrategy
+{
+    private array $stats;
+
+    public function __construct(
+        private readonly Cache $cache,
+        private readonly string $keyPrefix = 'db_query:'
+    ) {
+        $this->stats = [
+            'hits' => 0,
+            'misses' => 0,
+            'sets' => 0,
+            'deletes' => 0,
+            'invalidations' => 0,
+        ];
+    }
+
+    public function set(QueryCacheKey $key, array $value, int $ttlSeconds): bool
+    {
+        $fullKey = $this->keyPrefix . $key->toString();
+
+        try {
+            $success = $this->cache->set($fullKey, $value, $ttlSeconds);
+
+            if ($success) {
+                $this->stats['sets']++;
+            }
+
+            return $success;
+        } catch (\Throwable) {
+            return false;
+        }
+    }
+
+    public function get(QueryCacheKey $key): ?array
+    {
+        $fullKey = $this->keyPrefix . $key->toString();
+
+        try {
+            $value = $this->cache->get($fullKey);
+
+            if ($value === null) {
+                $this->stats['misses']++;
+                return null;
+            }
+
+            $this->stats['hits']++;
+            return $value->value;
+        } catch (\Throwable) {
+            $this->stats['misses']++;
+            return null;
+        }
+    }
+
+    public function has(QueryCacheKey $key): bool
+    {
+        $fullKey = $this->keyPrefix . $key->toString();
+
+        try {
+            return $this->cache->has($fullKey);
+        } catch (\Throwable) {
+            return false;
+        }
+    }
+
+    public function delete(QueryCacheKey $key): bool
+    {
+        $fullKey = $this->keyPrefix . $key->toString();
+
+        try {
+            $success = $this->cache->forget($fullKey);
+
+            if ($success) {
+                $this->stats['deletes']++;
+            }
+
+            return $success;
+        } catch (\Throwable) {
+            return false;
+        }
+    }
+
+    public function invalidatePattern(string $pattern): int
+    {
+        // Fallback für Cache-Implementierungen ohne Pattern-Support
+        if (!method_exists($this->cache, 'deleteByPattern')) {
+            // Für einfache Caches: kompletter Clear bei Pattern-Invalidierung
+            $this->clear();
+            return 1; // Unbekannte Anzahl, also 1 als Indikator
+        }
+
+        try {
+            $searchPattern = $this->keyPrefix . '*' . $pattern . '*';
+            $deleted = $this->cache->deleteByPattern($searchPattern);
+            $this->stats['invalidations'] += $deleted;
+            return $deleted;
+        } catch (\Throwable) {
+            return 0;
+        }
+    }
+
+    public function clear(): void
+    {
+        try {
+            // Wenn Cache Tagged-Cache unterstützt, nutze Tags
+            if (method_exists($this->cache, 'deleteByTag')) {
+                $deleted = $this->cache->deleteByTag('database_query');
+                $this->stats['invalidations'] += $deleted;
+                return;
+            }
+
+            // Wenn Pattern-Deletion unterstützt wird
+            if (method_exists($this->cache, 'deleteByPattern')) {
+                $deleted = $this->cache->deleteByPattern($this->keyPrefix . '*');
+                $this->stats['invalidations'] += $deleted;
+                return;
+            }
+
+            // Fallback: Ganzer Cache wird geleert (nicht ideal)
+            if (method_exists($this->cache, 'clear')) {
+                $this->cache->clear();
+                $this->stats['invalidations']++;
+            }
+        } catch (\Throwable) {
+            // Ignoriere Fehler bei Cache-Clear
+        }
+    }
+
+    public function getStats(): array
+    {
+        $baseStats = $this->stats;
+
+        // Erweitere um Framework-Cache-spezifische Stats falls verfügbar
+        if (method_exists($this->cache, 'getStats')) {
+            try {
+                $cacheStats = $this->cache->getStats();
+                $baseStats = array_merge($baseStats, [
+                    'cache_stats' => $cacheStats,
+                    'cache_type' => get_class($this->cache),
+                ]);
+            } catch (\Throwable) {
+                // Ignoriere Fehler bei Stats-Abruf
+            }
+        }
+
+        // Hit Ratio berechnen
+        $baseStats['hit_ratio'] = $this->calculateHitRatio();
+
+        return $baseStats;
+    }
+
+    private function calculateHitRatio(): float
+    {
+        $total = $this->stats['hits'] + $this->stats['misses'];
+        return $total > 0 ? ($this->stats['hits'] / $total) : 0.0;
+    }
+
+    /**
+     * Factory-Methode für TaggedCache wenn verfügbar
+     */
+    public static function withTags(Cache $cache, array $tags = ['database_query'], string $keyPrefix = 'db_query:'): self
+    {
+        // Wenn TaggedCache verfügbar ist, nutze es
+        if (method_exists($cache, 'tags')) {
+            $taggedCache = $cache->tags($tags);
+            return new self($taggedCache, $keyPrefix);
+        }
+
+        return new self($cache, $keyPrefix);
+    }
+
+    /**
+     * Hilfsmethode für Cache-Tagging
+     */
+    private function setWithTags(string $key, array $value, int $ttl, array $tags = []): bool
+    {
+        if (method_exists($this->cache, 'setWithTags')) {
+            return $this->cache->setWithTags($key, $value, $ttl, array_merge(['database_query'], $tags));
+        }
+
+        return $this->cache->set($key, $value, $ttl);
+    }
+
+    /**
+     * Invalidierung basierend auf Tabellen-Tags
+     */
+    public function invalidateByTable(string $tableName): int
+    {
+        if (method_exists($this->cache, 'deleteByTag')) {
+            try {
+                return $this->cache->deleteByTag("table:{$tableName}");
+            } catch (\Throwable) {
+                // Fallback zu Pattern-basierter Invalidierung
+            }
+        }
+
+        // Fallback: Pattern-basierte Invalidierung
+        return $this->invalidatePattern("*{$tableName}*");
+    }
+}
diff --git a/src/Framework/Database/Cache/CacheStrategy.php b/src/Framework/Database/Cache/CacheStrategy.php
new file mode 100644
index 00000000..cf430127
--- /dev/null
+++ b/src/Framework/Database/Cache/CacheStrategy.php
@@ -0,0 +1,43 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Database\Cache;
+
+interface CacheStrategy
+{
+    /**
+     * Speichert einen Wert im Cache
+     */
+    public function set(QueryCacheKey $key, array $value, int $ttlSeconds): bool;
+
+    /**
+     * Lädt einen Wert aus dem Cache
+     */
+    public function get(QueryCacheKey $key): ?array;
+
+    /**
+     * Prüft ob ein Schlüssel im Cache existiert
+     */
+    public function has(QueryCacheKey $key): bool;
+
+    /**
+     * Löscht einen Schlüssel aus dem Cache
+     */
+    public function delete(QueryCacheKey $key): bool;
+
+    /**
+     * Invalidiert Cache-Einträge basierend auf Pattern
+     */
+    public function invalidatePattern(string $pattern): int;
+
+    /**
+     * Löscht alle Cache-Einträge
+     */
+    public function clear(): void;
+
+    /**
+     * Gibt Cache-Statistiken zurück
+     */
+    public function getStats(): array;
+}
diff --git a/src/Framework/Database/Cache/QueryCacheKey.php b/src/Framework/Database/Cache/QueryCacheKey.php
new file mode 100644
index 00000000..9b37fbe3
--- /dev/null
+++ b/src/Framework/Database/Cache/QueryCacheKey.php
@@ -0,0 +1,148 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Database\Cache;
+
+use App\Framework\Database\ConnectionInterface;
+
+final readonly class QueryCacheKey
+{
+    private string $hashedKey;
+
+    public function __construct(
+        private string $sql,
+        private array $parameters,
+        private ConnectionInterface $connection
+    ) {
+        $this->hashedKey = $this->generateHash();
+    }
+
+    public function toString(): string
+    {
+        return $this->hashedKey;
+    }
+
+    public function __toString(): string
+    {
+        return $this->toString();
+    }
+
+    private function generateHash(): string
+    {
+        // Normalisiere SQL (Whitespace, Case)
+        $normalizedSql = $this->normalizeSql($this->sql);
+
+        // Sortiere Parameter für konsistente Hashes
+        $sortedParams = $this->normalizeParameters($this->parameters);
+
+        // Verwende Connection-spezifische Daten
+        $connectionInfo = $this->getConnectionInfo();
+
+        // Generiere deterministische Hash
+        $keyData = [
+            'sql' => $normalizedSql,
+            'params' => $sortedParams,
+            'connection' => $connectionInfo,
+        ];
+
+        $serialized = serialize($keyData);
+        return 'query_cache:' . hash('sha256', $serialized);
+    }
+
+    private function normalizeSql(string $sql): string
+    {
+        // Entferne überflüssige Zeichen und normalisiere
+        $normalized = preg_replace('/\s+/', ' ', trim($sql));
+        return strtolower($normalized);
+    }
+
+    private function normalizeParameters(array $parameters): array
+    {
+        // Für assoziative Arrays: nach Schlüssel sortieren
+        if ($this->isAssociativeArray($parameters)) {
+            ksort($parameters);
+        }
+
+        // Normalisiere Werte
+        return array_map([$this, 'normalizeValue'], $parameters);
+    }
+
+    private function normalizeValue(mixed $value): mixed
+    {
+        // Strings trimmen
+        if (is_string($value)) {
+            return trim($value);
+        }
+
+        // Floats mit fester Präzision
+        if (is_float($value)) {
+            return round($value, 10);
+        }
+
+        // Objects zu String konvertieren wenn möglich
+        if (is_object($value) && method_exists($value, '__toString')) {
+            return (string) $value;
+        }
+
+        return $value;
+    }
+
+    private function isAssociativeArray(array $array): bool
+    {
+        return array_keys($array) !== range(0, count($array) - 1);
+    }
+
+    private function getConnectionInfo(): array
+    {
+        try {
+            $pdo = $this->connection->getPdo();
+
+            return [
+                'driver' => $pdo->getAttribute(\PDO::ATTR_DRIVER_NAME),
+                'server_version' => $pdo->getAttribute(\PDO::ATTR_SERVER_VERSION),
+                // Keine sensitive Daten wie Host/Database für bessere Portabilität
+            ];
+        } catch (\Throwable) {
+            return ['driver' => 'unknown'];
+        }
+    }
+
+    public function getSql(): string
+    {
+        return $this->sql;
+    }
+
+    public function getParameters(): array
+    {
+        return $this->parameters;
+    }
+
+    public function matches(string $pattern): bool
+    {
+        // Ermöglicht Pattern-basierte Invalidierung
+        return fnmatch($pattern, $this->hashedKey) ||
+               str_contains($this->normalizeSql($this->sql), strtolower($pattern));
+    }
+
+    public function containsTable(string $tableName): bool
+    {
+        $normalizedSql = $this->normalizeSql($this->sql);
+
+        // Einfache Heuristik für Tabellenerkennung
+        $patterns = [
+            " from {$tableName} ",
+            " join {$tableName} ",
+            " into {$tableName} ",
+            " update {$tableName} ",
+        ];
+
+        foreach ($patterns as $pattern) {
+            if (str_contains($normalizedSql, strtolower($pattern))) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+}
diff --git a/src/Framework/Database/Cache/SimpleCacheStrategy.php b/src/Framework/Database/Cache/SimpleCacheStrategy.php
new file mode 100644
index 00000000..3722bc02
--- /dev/null
+++ b/src/Framework/Database/Cache/SimpleCacheStrategy.php
@@ -0,0 +1,138 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Database\Cache;
+
+/**
+ * Einfache Cache-Strategy als Fallback wenn kein Framework-Cache verfügbar
+ */
+final class SimpleCacheStrategy implements CacheStrategy
+{
+    private array $cache = [];
+    private array $expiry = [];
+    private array $stats = [
+        'hits' => 0,
+        'misses' => 0,
+        'sets' => 0,
+        'deletes' => 0,
+        'invalidations' => 0,
+    ];
+
+    public function __construct(
+        private readonly string $keyPrefix = 'db_query:'
+    ) {}
+
+    public function set(QueryCacheKey $key, array $value, int $ttlSeconds): bool
+    {
+        $keyString = $this->keyPrefix . $key->toString();
+
+        $this->cache[$keyString] = $value;
+        $this->expiry[$keyString] = time() + $ttlSeconds;
+        $this->stats['sets']++;
+
+        return true;
+    }
+
+    public function get(QueryCacheKey $key): ?array
+    {
+        $keyString = $this->keyPrefix . $key->toString();
+
+        // Prüfe Ablauf
+        if (isset($this->expiry[$keyString]) && time() > $this->expiry[$keyString]) {
+            $this->delete($key);
+            $this->stats['misses']++;
+            return null;
+        }
+
+        if (isset($this->cache[$keyString])) {
+            $this->stats['hits']++;
+            return $this->cache[$keyString];
+        }
+
+        $this->stats['misses']++;
+        return null;
+    }
+
+    public function has(QueryCacheKey $key): bool
+    {
+        return $this->get($key) !== null;
+    }
+
+    public function delete(QueryCacheKey $key): bool
+    {
+        $keyString = $this->keyPrefix . $key->toString();
+
+        $existed = isset($this->cache[$keyString]);
+
+        unset($this->cache[$keyString], $this->expiry[$keyString]);
+
+        if ($existed) {
+            $this->stats['deletes']++;
+        }
+
+        return $existed;
+    }
+
+    public function invalidatePattern(string $pattern): int
+    {
+        $deleted = 0;
+
+        foreach (array_keys($this->cache) as $keyString) {
+            if (fnmatch($pattern, $keyString)) {
+                unset($this->cache[$keyString], $this->expiry[$keyString]);
+                $deleted++;
+            }
+        }
+
+        $this->stats['invalidations'] += $deleted;
+        return $deleted;
+    }
+
+    public function clear(): void
+    {
+        $count = count($this->cache);
+        $this->cache = [];
+        $this->expiry = [];
+        $this->stats['invalidations'] += $count;
+    }
+
+    public function getStats(): array
+    {
+        return array_merge($this->stats, [
+            'size' => count($this->cache),
+            'memory_usage' => $this->estimateMemoryUsage(),
+            'hit_ratio' => $this->calculateHitRatio(),
+            'cache_type' => 'SimpleCacheStrategy'
+        ]);
+    }
+
+    private function estimateMemoryUsage(): int
+    {
+        return memory_get_usage() - memory_get_usage(true); // Grobe Schätzung
+    }
+
+    private function calculateHitRatio(): float
+    {
+        $total = $this->stats['hits'] + $this->stats['misses'];
+        return $total > 0 ? ($this->stats['hits'] / $total) : 0.0;
+    }
+
+    /**
+     * Bereinigt abgelaufene Einträge
+     */
+    public function cleanup(): int
+    {
+        $currentTime = time();
+        $cleaned = 0;
+
+        foreach ($this->expiry as $keyString => $expiry) {
+            if ($currentTime > $expiry) {
+                unset($this->cache[$keyString], $this->expiry[$keyString]);
+                $cleaned++;
+            }
+        }
+
+        return $cleaned;
+    }
+}
diff --git a/src/Framework/Database/Config/DatabaseConfig.php b/src/Framework/Database/Config/DatabaseConfig.php
new file mode 100644
index 00000000..845c2854
--- /dev/null
+++ b/src/Framework/Database/Config/DatabaseConfig.php
@@ -0,0 +1,14 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Database\Config;
+
+use App\Framework\Database\Driver\DriverConfig;
+
+final class DatabaseConfig
+{
+    public function __construct(
+        public DriverConfig $driverConfig,
+        public PoolConfig $poolConfig,
+    ) {}
+}
diff --git a/src/Framework/Database/Config/PoolConfig.php b/src/Framework/Database/Config/PoolConfig.php
new file mode 100644
index 00000000..92e85e70
--- /dev/null
+++ b/src/Framework/Database/Config/PoolConfig.php
@@ -0,0 +1,13 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Database\Config;
+
+final class PoolConfig
+{
+    public function __construct(
+        public bool $enabled,
+        public int $maxConnections,
+        public int $minConnections,
+    ) {}
+}
diff --git a/src/Framework/Database/ConnectionInterface.php b/src/Framework/Database/ConnectionInterface.php
new file mode 100644
index 00000000..f1d8f7e8
--- /dev/null
+++ b/src/Framework/Database/ConnectionInterface.php
@@ -0,0 +1,29 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Database;
+
+interface ConnectionInterface
+{
+    public function execute(string $sql, array $parameters = []): int;
+
+    public function query(string $sql, array $parameters = []): ResultInterface;
+
+    public function queryOne(string $sql, array $parameters = []): ?array;
+
+    public function queryColumn(string $sql, array $parameters = []): array;
+
+    public function queryScalar(string $sql, array $parameters = []): mixed;
+
+    public function beginTransaction(): void;
+
+    public function commit(): void;
+
+    public function rollback(): void;
+
+    public function inTransaction(): bool;
+
+    public function lastInsertId(): string;
+
+    public function getPdo(): \PDO;
+}
diff --git a/src/Framework/Database/ConnectionPool.php b/src/Framework/Database/ConnectionPool.php
new file mode 100644
index 00000000..022c9bfd
--- /dev/null
+++ b/src/Framework/Database/ConnectionPool.php
@@ -0,0 +1,86 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Database;
+
+use App\Framework\Database\Exception\DatabaseException;
+
+final class ConnectionPool
+{
+    private array $config;
+    private array $connections = [];
+    private array $inUse = [];
+    private int $maxConnections;
+    private int $minConnections;
+    private int $currentConnections = 0;
+
+    public function __construct(array $config, int $maxConnections = 10, int $minConnections = 2)
+    {
+        $this->config = $config;
+        $this->maxConnections = $maxConnections;
+        $this->minConnections = $minConnections;
+
+        $this->initializeMinConnections();
+    }
+
+    public function getConnection(): PooledConnection
+    {
+        foreach ($this->connections as $id => $connection) {
+            if (!isset($this->inUse[$id])) {
+                $this->inUse[$id] = true;
+                return new PooledConnection($connection, $this, $id);
+            }
+        }
+
+        if ($this->currentConnections < $this->maxConnections) {
+            $connection = DatabaseFactory::createConnection($this->config);
+            $id = uniqid('conn_');
+            $this->connections[$id] = $connection;
+            $this->inUse[$id] = true;
+            $this->currentConnections++;
+
+            return new PooledConnection($connection, $this, $id);
+        }
+
+        throw new DatabaseException('Maximum number of connections reached');
+    }
+
+    public function releaseConnection(string $id): void
+    {
+        unset($this->inUse[$id]);
+    }
+
+    public function closeConnection(string $id): void
+    {
+        unset($this->connections[$id], $this->inUse[$id]);
+        $this->currentConnections--;
+    }
+
+    public function getStats(): array
+    {
+        return [
+            'total_connections' => $this->currentConnections,
+            'active_connections' => count($this->inUse),
+            'free_connections' => $this->currentConnections - count($this->inUse),
+            'max_connections' => $this->maxConnections,
+        ];
+    }
+
+    private function initializeMinConnections(): void
+    {
+        for ($i = 0; $i < $this->minConnections; $i++) {
+            $connection = DatabaseFactory::createConnection($this->config);
+            $id = uniqid('conn_');
+            $this->connections[$id] = $connection;
+            $this->currentConnections++;
+        }
+    }
+
+    public function __destruct()
+    {
+        $this->connections = [];
+        $this->inUse = [];
+        $this->currentConnections = 0;
+    }
+}
diff --git a/src/Framework/Database/DatabaseFactory.php b/src/Framework/Database/DatabaseFactory.php
new file mode 100644
index 00000000..32698237
--- /dev/null
+++ b/src/Framework/Database/DatabaseFactory.php
@@ -0,0 +1,332 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Database;
+
+use App\Framework\Cache\Cache;
+use App\Framework\Database\Cache\CacheStrategy;
+use App\Framework\Database\ConnectionInterface;
+use App\Framework\Database\Driver\Driver;
+use App\Framework\Database\Driver\DriverConfig;
+use App\Framework\Database\Driver\DriverType;
+use App\Framework\Database\Driver\MysqlDriver;
+use App\Framework\Database\Driver\PostgresDriver;
+use App\Framework\Database\Driver\SqliteDriver;
+use App\Framework\Database\Exception\DatabaseException;
+use App\Framework\Database\Middleware\MiddlewarePipeline;
+use App\Framework\Database\Middleware\CacheMiddleware;
+use App\Framework\Database\Middleware\RetryMiddleware;
+use App\Framework\Database\Middleware\HealthCheckMiddleware;
+use App\Framework\Database\Cache\CacheAdapterStrategy;
+use App\Framework\Database\Cache\SimpleCacheStrategy;
+use Pdo\Mysql;
+use Pdo\Pgsql;
+use Pdo\Sqlite;
+
+final readonly class DatabaseFactory
+{
+    public static function createConnection(
+        array|DriverConfig $config,
+        array $middlewareConfig = []
+    ): ConnectionInterface {
+        $lazy = $middlewareConfig['lazy'] ?? false;
+        $retry = $middlewareConfig['retry'] ?? false;
+        $healthCheck = $middlewareConfig['health_check'] ?? false;
+        $cache = $middlewareConfig['cache'] ?? false;
+
+        if (!$lazy && !$retry && !$healthCheck && !$cache) {
+            // Keine Middleware - direkte Verbindung
+            return self::createDirectConnection($config);
+        }
+
+        // Base Connection erstellen
+        if ($lazy) {
+            $baseConnection = LazyConnectionFactory::createLazyGhost($config);
+        } else {
+            $baseConnection = self::createDirectConnection($config);
+        }
+
+        // Middleware-Pipeline erstellen
+        $pipeline = new MiddlewarePipeline();
+
+        if ($cache) {
+            $cacheConfig = is_array($cache) ? $cache : [];
+            $cacheStrategy = self::createCacheStrategy($cacheConfig);
+
+            $pipeline->add(new CacheMiddleware(
+                $cacheStrategy,
+                $cacheConfig['ttl'] ?? 300,
+                $cacheConfig['enabled'] ?? true,
+                $cacheConfig['cacheable_operations'] ?? ['query', 'queryOne', 'queryColumn', 'queryScalar']
+            ));
+        }
+
+        if ($retry) {
+            $retryConfig = is_array($retry) ? $retry : [];
+            $pipeline->add(new RetryMiddleware(
+                $retryConfig['max_retries'] ?? 3,
+                $retryConfig['delay_ms'] ?? 100,
+                $retryConfig['retryable_exceptions'] ?? [\PDOException::class, DatabaseException::class]
+            ));
+        }
+
+        if ($healthCheck) {
+            $healthConfig = is_array($healthCheck) ? $healthCheck : [];
+            $pipeline->add(new HealthCheckMiddleware(
+                $healthConfig['interval'] ?? 30,
+                $healthConfig['enabled'] ?? true
+            ));
+        }
+
+        // Wenn Pipeline leer ist, gib direkt die Base Connection zurück
+        if (empty($pipeline->getMiddleware())) {
+            return $baseConnection;
+        }
+
+        return new MiddlewareConnection($baseConnection, $pipeline);
+    }
+
+    public static function createDirectConnection(array|DriverConfig $config): ConnectionInterface
+    {
+        if(is_array($config)) {
+            $config = DriverConfig::fromArray($config);
+        }
+
+        $driver = self::createDriver($config);
+        $pdo = self::createPdo($driver);
+
+        return new PdoConnection($pdo);
+    }
+
+    public static function createLazyConnection(
+        array|DriverConfig $config,
+        array $additionalMiddleware = []
+    ): ConnectionInterface {
+        return self::createConnection($config, array_merge(
+            ['lazy' => true],
+            $additionalMiddleware
+        ));
+    }
+
+    public static function createRetryableConnection(
+        array|DriverConfig $config,
+        int $maxRetries = 3,
+        int $retryDelayMs = 100
+    ): ConnectionInterface {
+        return self::createConnection($config, [
+            'retry' => [
+                'max_retries' => $maxRetries,
+                'delay_ms' => $retryDelayMs
+            ]
+        ]);
+    }
+
+    public static function createRobustConnection(
+        array|DriverConfig $config,
+        array $middlewareConfig = []
+    ): ConnectionInterface {
+        // Standard "robuste" Konfiguration
+        $defaultConfig = [
+            'lazy' => true,
+            'retry' => [
+                'max_retries' => 3,
+                'delay_ms' => 100
+            ],
+            'health_check' => [
+                'interval' => 30,
+                'enabled' => true
+            ]
+        ];
+
+        return self::createConnection($config, array_merge($defaultConfig, $middlewareConfig));
+    }
+
+    public static function createPureLazyConnection(array|DriverConfig $config): ConnectionInterface
+    {
+        // Reine LazyGhost-Connection ohne zusätzliche Middleware
+        return LazyConnectionFactory::createLazyGhost($config);
+    }
+
+    public static function isLazyConnection(ConnectionInterface $connection): bool
+    {
+        if ($connection instanceof MiddlewareConnection) {
+            $baseConnection = $connection->getBaseConnection();
+            return LazyConnectionFactory::isLazyGhost($baseConnection);
+        }
+
+        return LazyConnectionFactory::isLazyGhost($connection);
+    }
+
+    public static function forceLazyInitialization(ConnectionInterface $connection): void
+    {
+        if ($connection instanceof MiddlewareConnection) {
+            $baseConnection = $connection->getBaseConnection();
+            if (LazyConnectionFactory::isLazyGhost($baseConnection)) {
+                LazyConnectionFactory::initializeLazyGhost($baseConnection);
+            }
+        } elseif (LazyConnectionFactory::isLazyGhost($connection)) {
+            LazyConnectionFactory::initializeLazyGhost($connection);
+        }
+    }
+
+    private static function createCacheStrategy(array $config): CacheStrategy
+    {
+        // Verwende direktes CacheInterface oder fallback zu ArrayCache
+        $keyPrefix = $config['prefix'] ?? 'db_query:';
+        $tags = $config['tags'] ?? ['database_query'];
+
+        // Wenn eine CacheInterface-Instanz direkt übergeben wird
+        if (isset($config['cache_instance']) && $config['cache_instance'] instanceof Cache) {
+            return new CacheAdapterStrategy($config['cache_instance'], $keyPrefix);
+        }
+
+        // Fallback zu einfacher Array-basierter Implementierung
+        return new SimpleCacheStrategy($keyPrefix);
+    }
+
+    /**
+     * Erstelle Cache-Strategy mit direkter CacheInterface-Instanz
+     */
+    public static function createCacheStrategyFromCache(
+        Cache $cache,
+        string $keyPrefix = 'db_query:',
+        array $tags = ['database_query']
+    ): CacheStrategy {
+        return CacheAdapterStrategy::withTags($cache, $tags, $keyPrefix);
+    }
+
+    public static function createCachedConnection(
+        array|DriverConfig $config,
+        array $cacheConfig = []
+    ): ConnectionInterface {
+        return self::createConnection($config, [
+            'cache' => array_merge([
+                'ttl' => 300,
+                'enabled' => true,
+                'prefix' => 'db_query:',
+                'tags' => ['database_query']
+            ], $cacheConfig)
+        ]);
+    }
+
+    public static function createCachedConnectionWithCache(
+        array|DriverConfig $config,
+        Cache $cache,
+        array $additionalConfig = []
+    ): ConnectionInterface {
+        return self::createCachedConnection($config, array_merge([
+            'cache_instance' => $cache
+        ], $additionalConfig));
+    }
+
+    /**
+     * Erstelle Connection mit externem Cache-System
+     */
+    public static function createConnectionWithCustomCache(
+        array|DriverConfig $config,
+        Cache $cache,
+        string $keyPrefix = 'db_query:',
+        int $ttl = 300
+    ): ConnectionInterface {
+        return self::createConnection($config, [
+            'cache' => [
+                'cache_instance' => $cache,
+                'prefix' => $keyPrefix,
+                'ttl' => $ttl,
+                'enabled' => true
+            ]
+        ]);
+    }
+
+    public static function createFullFeaturedConnection(
+        array|DriverConfig $config,
+        array $middlewareConfig = []
+    ): ConnectionInterface {
+        // "Alles dabei" - Connection mit allen Features
+        $defaultConfig = [
+            'lazy' => true,
+            'cache' => [
+                'ttl' => 300,
+                'enabled' => true,
+                'prefix' => 'db_query:',
+                'tags' => ['database_query']
+            ],
+            'retry' => [
+                'max_retries' => 3,
+                'delay_ms' => 100
+            ],
+            'health_check' => [
+                'interval' => 30,
+                'enabled' => true
+            ]
+        ];
+
+        return self::createConnection($config, array_merge($defaultConfig, $middlewareConfig));
+    }
+
+    public static function createProductionConnection(
+        array|DriverConfig $config,
+        ?Cache $cache = null,
+        array $middlewareConfig = []
+    ): ConnectionInterface {
+        // Production-optimierte Konfiguration
+        $defaultConfig = [
+            'lazy' => true,
+            'cache' => [
+                'ttl' => 1800,
+                'enabled' => true,
+                'prefix' => 'prod_db:',
+                'tags' => ['database_query', 'production']
+            ],
+            'retry' => [
+                'max_retries' => 5,
+                'delay_ms' => 200
+            ],
+            'health_check' => [
+                'interval' => 60,
+                'enabled' => true
+            ]
+        ];
+
+        // Wenn externe Cache-Instanz übergeben wird
+        if ($cache !== null) {
+            $defaultConfig['cache']['cache_instance'] = $cache;
+        }
+
+        return self::createConnection($config, array_merge($defaultConfig, $middlewareConfig));
+    }
+
+    private static function createDriver(DriverConfig $config): Driver
+    {
+        return match($config->driverType) {
+            DriverType::MYSQL => new MysqlDriver($config),
+            DriverType::PGSQL => new PostgresDriver($config),
+            DriverType::SQLITE => new SqliteDriver($config),
+        };
+    }
+
+    private static function createPdo(Driver $driver): \PDO
+    {
+        return match($driver->config->driverType) {
+            DriverType::MYSQL => new Mysql(
+                $driver->dsn,
+                $driver->config->username,
+                $driver->config->password,
+                $driver->options
+            ),
+            DriverType::PGSQL => new Pgsql(
+                $driver->dsn,
+                $driver->config->username,
+                $driver->config->password,
+                $driver->options
+            ),
+            DriverType::SQLITE => new Sqlite(
+                $driver->dsn,
+                $driver->config->username,
+                $driver->config->password,
+                $driver->options
+            ),
+        };
+    }
+}
diff --git a/src/Framework/Database/DatabaseManager.php b/src/Framework/Database/DatabaseManager.php
new file mode 100644
index 00000000..f4c6f89f
--- /dev/null
+++ b/src/Framework/Database/DatabaseManager.php
@@ -0,0 +1,105 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Database;
+
+use App\Framework\Database\Migration\MigrationLoader;
+use App\Framework\Database\Migration\MigrationRunner;
+
+final class DatabaseManager
+{
+    private array $config;
+    private ?ConnectionPool $connectionPool = null;
+    private ?ReadWriteConnection $readWriteConnection = null;
+
+    public function __construct(
+        array $config = [],
+        private readonly string $migrationsPath = 'database/migrations'
+    ){
+        $this->config = $config;
+    }
+
+    public function getConnection(): ConnectionInterface
+    {
+        if (isset($this->config['pool']) && $this->config['pool']['enabled']) {
+            return $this->getPooledConnection();
+        }
+
+        if (isset($this->config['read_write']) && $this->config['read_write']['enabled']) {
+            return $this->getReadWriteConnection();
+        }
+
+        return DatabaseFactory::createConnection($this->config);
+    }
+
+    public function getPooledConnection(): PooledConnection
+    {
+        if ($this->connectionPool === null) {
+            $poolConfig = $this->config['pool'] ?? [];
+            $this->connectionPool = new ConnectionPool(
+                $this->config,
+                $poolConfig['max_connections'] ?? 10,
+                $poolConfig['min_connections'] ?? 2
+            );
+        }
+
+        return $this->connectionPool->getConnection();
+    }
+
+    public function getReadWriteConnection(): ReadWriteConnection
+    {
+        if ($this->readWriteConnection === null) {
+            $writeConnection = DatabaseFactory::createConnection($this->config);
+
+            $readConnections = [];
+            foreach ($this->config['read_write']['read_connections'] as $readConfig) {
+                $readConnections[] = DatabaseFactory::createConnection(
+                    array_merge($this->config, $readConfig)
+                );
+            }
+
+            $this->readWriteConnection = new ReadWriteConnection($writeConnection, $readConnections);
+        }
+
+        return $this->readWriteConnection;
+    }
+
+    public function migrate(?string $migrationsPath = null): array
+    {
+        $migrationsPath = $migrationsPath ?? $this->migrationsPath;
+
+        $loader = new MigrationLoader($migrationsPath);
+        $migrations = $loader->loadMigrations();
+
+        $runner = new MigrationRunner($this->getConnection());
+        return $runner->migrate($migrations);
+    }
+
+    public function rollback(?string $migrationsPath = null, int $steps = 1): array
+    {
+        $migrationsPath = $migrationsPath ?? $this->migrationsPath;
+
+        $loader = new MigrationLoader($migrationsPath);
+        $migrations = $loader->loadMigrations();
+
+        $runner = new MigrationRunner($this->getConnection());
+        return $runner->rollback($migrations, $steps);
+    }
+
+    public function getMigrationStatus(?string $migrationsPath = null): array
+    {
+        $migrationsPath = $migrationsPath ?? $this->migrationsPath;
+
+        $loader = new MigrationLoader($migrationsPath);
+        $migrations = $loader->loadMigrations();
+
+        $runner = new MigrationRunner($this->getConnection());
+        return $runner->getStatus($migrations);
+    }
+
+    public function getConnectionPoolStats(): array
+    {
+        return $this->connectionPool?->getStats() ?? [];
+    }
+}
diff --git a/src/Framework/Database/Driver/Driver.php b/src/Framework/Database/Driver/Driver.php
new file mode 100644
index 00000000..530586b3
--- /dev/null
+++ b/src/Framework/Database/Driver/Driver.php
@@ -0,0 +1,16 @@
+<?php
+
+namespace App\Framework\Database\Driver;
+
+interface Driver
+{
+    public string $dsn {get;}
+
+    public array $options {get;}
+
+    public DriverConfig $config {get;}
+
+    public function __construct(
+        DriverConfig $config
+    );
+}
diff --git a/src/Framework/Database/Driver/DriverConfig.php b/src/Framework/Database/Driver/DriverConfig.php
new file mode 100644
index 00000000..6a6acccd
--- /dev/null
+++ b/src/Framework/Database/Driver/DriverConfig.php
@@ -0,0 +1,29 @@
+<?php
+
+namespace App\Framework\Database\Driver;
+
+final readonly class DriverConfig
+{
+    public function __construct(
+        public DriverType $driverType,
+        public string $host,
+        public int $port,
+        public string $database,
+        public string $username,
+        public string $password,
+        public string $charset
+    ){}
+
+    public static function fromArray(array $config): DriverConfig
+    {
+        return new self(
+            driverType: DriverType::tryFrom($config['driver']) ?? DriverType::MYSQL,
+            host: $config['host'],
+            port: $config['port'],
+            database: $config['database'],
+            username: $config['username'],
+            password: $config['password'],
+            charset: $config['charset'] ?? 'utf8mb4'
+        );
+    }
+}
diff --git a/src/Framework/Database/Driver/DriverType.php b/src/Framework/Database/Driver/DriverType.php
new file mode 100644
index 00000000..791472a6
--- /dev/null
+++ b/src/Framework/Database/Driver/DriverType.php
@@ -0,0 +1,12 @@
+<?php
+
+namespace App\Framework\Database\Driver;
+
+enum DriverType:string
+{
+    case MYSQL = 'mysql';
+
+    case PGSQL = 'pgsql';
+
+    case SQLITE = 'sqlite';
+}
diff --git a/src/Framework/Database/Driver/MysqlDriver.php b/src/Framework/Database/Driver/MysqlDriver.php
new file mode 100644
index 00000000..299d1554
--- /dev/null
+++ b/src/Framework/Database/Driver/MysqlDriver.php
@@ -0,0 +1,37 @@
+<?php
+
+namespace App\Framework\Database\Driver;
+
+final readonly class MysqlDriver implements Driver
+{
+    public string $dsn;
+
+    public array $options;
+
+    public function __construct(
+        public DriverConfig $config,
+    ){
+        $this->dsn = $this->createDns();
+        $this->options = $this->getOptions();
+    }
+
+    private function createDns(): string
+    {
+        return sprintf(
+            'mysql:host=%s;port=%d;dbname=%s;charset=%s',
+            $this->config->host,
+            $this->config->port,
+            $this->config->database,
+            $this->config->charset,
+        );
+    }
+
+    private function getOptions(): array
+    {
+        return [
+            \PDO::ATTR_ERRMODE => \PDO::ERRMODE_EXCEPTION,
+            \PDO::ATTR_DEFAULT_FETCH_MODE => \PDO::FETCH_ASSOC,
+            \PDO::ATTR_EMULATE_PREPARES => false,
+        ];
+    }
+}
diff --git a/src/Framework/Database/Driver/PostgresDriver.php b/src/Framework/Database/Driver/PostgresDriver.php
new file mode 100644
index 00000000..2ea505ec
--- /dev/null
+++ b/src/Framework/Database/Driver/PostgresDriver.php
@@ -0,0 +1,38 @@
+<?php
+
+namespace App\Framework\Database\Driver;
+
+final readonly class PostgresDriver implements Driver
+{
+    public string $dsn;
+
+    public array $options;
+
+    public function __construct(
+        public DriverConfig $config,
+    ){
+        $this->dsn = $this->createDns();
+        $this->options = $this->getOptions();
+    }
+
+    private function createDns(): string
+    {
+        return sprintf(
+            'pgsql:host=%s;port=%d;dbname=%s',
+            $this->config->host,
+            $this->config->port,
+            $this->config->database,
+        );
+    }
+
+    private function getOptions(): array
+    {
+        return [
+            \PDO::ATTR_ERRMODE => \PDO::ERRMODE_EXCEPTION,
+            \PDO::ATTR_DEFAULT_FETCH_MODE => \PDO::FETCH_ASSOC,
+            \PDO::ATTR_EMULATE_PREPARES => false,
+            // PostgreSQL-spezifische Optionen
+            \PDO::ATTR_PERSISTENT => false,
+        ];
+    }
+}
diff --git a/src/Framework/Database/Driver/SqliteDriver.php b/src/Framework/Database/Driver/SqliteDriver.php
new file mode 100644
index 00000000..335d5634
--- /dev/null
+++ b/src/Framework/Database/Driver/SqliteDriver.php
@@ -0,0 +1,39 @@
+<?php
+
+namespace App\Framework\Database\Driver;
+
+final readonly class SqliteDriver implements Driver
+{
+    public string $dsn;
+
+    public array $options;
+
+    public function __construct(
+        public DriverConfig $config,
+    ){
+        $this->dsn = $this->createDns();
+        $this->options = $this->getOptions();
+    }
+
+    private function createDns(): string
+    {
+        // Für SQLite verwenden wir den database-Parameter als Dateipfad
+        // Falls es ein relativer Pfad ist, wird er relativ zum aktuellen Verzeichnis interpretiert
+        // Für In-Memory-Datenbank kann ":memory:" verwendet werden
+        return sprintf(
+            'sqlite:%s',
+            $this->config->database
+        );
+    }
+
+    private function getOptions(): array
+    {
+        return [
+            \PDO::ATTR_ERRMODE => \PDO::ERRMODE_EXCEPTION,
+            \PDO::ATTR_DEFAULT_FETCH_MODE => \PDO::FETCH_ASSOC,
+            \PDO::ATTR_EMULATE_PREPARES => false,
+            // SQLite-spezifische Optionen
+            \PDO::ATTR_TIMEOUT => 30,
+        ];
+    }
+}
diff --git a/src/Framework/Database/EntityManager.php b/src/Framework/Database/EntityManager.php
new file mode 100644
index 00000000..9df2f85e
--- /dev/null
+++ b/src/Framework/Database/EntityManager.php
@@ -0,0 +1,469 @@
+<?php
+
+namespace App\Framework\Database;
+
+use App\Framework\Attributes\Singleton;
+use App\Framework\Database\Metadata\EntityMetadata;
+use App\Framework\Database\Metadata\MetadataRegistry;
+
+#[Singleton]
+final readonly class EntityManager
+{
+    private Hydrator $hydrator;
+    public function __construct(
+        private DatabaseManager $databaseManager,
+        private MetadataRegistry $metadataRegistry,
+        private TypeConverter $typeConverter,
+        private IdentityMap $identityMap,
+        private LazyLoader $lazyLoader
+    ) {
+
+        $this->hydrator = new Hydrator($this->typeConverter, $this);
+    }
+
+    /**
+     * Findet Entity - standardmäßig lazy loading
+     */
+    public function find(string $entityClass, mixed $id): ?object
+    {
+        // Prüfe Identity Map zuerst
+        if ($this->identityMap->has($entityClass, $id)) {
+            return $this->identityMap->get($entityClass, $id);
+        }
+
+        return $this->findWithLazyLoading($entityClass, $id);
+    }
+
+    /**
+     * Findet Entity und lädt sie sofort (eager loading)
+     */
+    public function findEager(string $entityClass, mixed $id): ?object
+    {
+        // Prüfe Identity Map zuerst
+        if ($this->identityMap->has($entityClass, $id)) {
+            $entity = $this->identityMap->get($entityClass, $id);
+
+            // Falls es ein Ghost ist, initialisiere es
+            if ($this->isLazyGhost($entity)) {
+                $this->initializeLazyObject($entity);
+            }
+
+            return $entity;
+        }
+
+        $metadata = $this->metadataRegistry->getMetadata($entityClass);
+
+        $query = "SELECT * FROM {$metadata->tableName} WHERE {$metadata->idColumn} = ?";
+        $result = $this->databaseManager->getConnection()->query($query, [$id]);
+        $data = $result->fetch();
+
+        if (!$data) {
+            return null;
+        }
+
+        $entity = $this->hydrator->hydrate($metadata, $data);
+
+        // In Identity Map speichern
+        $this->identityMap->set($entityClass, $id, $entity);
+
+        return $entity;
+    }
+
+    /**
+     * Interne Methode für Lazy Loading
+     */
+    private function findWithLazyLoading(string $entityClass, mixed $id): ?object
+    {
+        // Prüfe ob Entity existiert (schneller Check)
+        $metadata = $this->metadataRegistry->getMetadata($entityClass);
+
+        $query = "SELECT {$metadata->idColumn} FROM {$metadata->tableName} WHERE {$metadata->idColumn} = ?";
+        $result = $this->databaseManager->getConnection()->query($query, [$id]);
+
+        if (!$result->fetch()) {
+            return null;
+        }
+
+        // Erstelle Lazy Ghost
+        return $this->lazyLoader->createLazyGhost($metadata, $id);
+    }
+
+    /**
+     * Referenz auf Entity (ohne Existenz-Check)
+     */
+    public function getReference(string $entityClass, mixed $id): object
+    {
+        // Prüfe Identity Map
+        if ($this->identityMap->has($entityClass, $id)) {
+            return $this->identityMap->get($entityClass, $id);
+        }
+
+        $metadata = $this->metadataRegistry->getMetadata($entityClass);
+        return $this->lazyLoader->createLazyGhost($metadata, $id);
+    }
+
+    /**
+     * Findet alle Entities - standardmäßig lazy
+     */
+    public function findAll(string $entityClass): array
+    {
+        return $this->findAllLazy($entityClass);
+    }
+
+    /**
+     * Findet alle Entities und lädt sie sofort
+     */
+    public function findAllEager(string $entityClass): array
+    {
+        $metadata = $this->metadataRegistry->getMetadata($entityClass);
+
+        $query = "SELECT * FROM {$metadata->tableName}";
+        $result = $this->databaseManager->getConnection()->query($query);
+
+        $entities = [];
+        foreach ($result->fetchAll() as $data) {
+            // Prüfe Identity Map für jede Entity
+            $idValue = $data[$metadata->idColumn];
+
+            if ($this->identityMap->has($entityClass, $idValue)) {
+                $entity = $this->identityMap->get($entityClass, $idValue);
+
+                // Falls Ghost, initialisiere es für eager loading
+                if ($this->isLazyGhost($entity)) {
+                    $this->initializeLazyObject($entity);
+                }
+
+                $entities[] = $entity;
+            } else {
+                $entity = $this->hydrator->hydrate($metadata, $data);
+                $this->identityMap->set($entityClass, $idValue, $entity);
+                $entities[] = $entity;
+            }
+        }
+
+        return $entities;
+    }
+
+    /**
+     * Interne Methode für lazy findAll
+     */
+    private function findAllLazy(string $entityClass): array
+    {
+        $metadata = $this->metadataRegistry->getMetadata($entityClass);
+
+        // Nur IDs laden
+        $query = "SELECT {$metadata->idColumn} FROM {$metadata->tableName}";
+        $result = $this->databaseManager->getConnection()->query($query);
+
+        $entities = [];
+        foreach ($result->fetchAll() as $data) {
+            $idValue = $data[$metadata->idColumn];
+
+            if ($this->identityMap->has($entityClass, $idValue)) {
+                $entities[] = $this->identityMap->get($entityClass, $idValue);
+            } else {
+                $entities[] = $this->lazyLoader->createLazyGhost($metadata, $idValue);
+            }
+        }
+
+        return $entities;
+    }
+
+    /**
+     * Findet Entities nach Kriterien
+     */
+    public function findBy(string $entityClass, array $criteria, ?array $orderBy = null, ?int $limit = null): array
+    {
+        $metadata = $this->metadataRegistry->getMetadata($entityClass);
+
+        $query = "SELECT {$metadata->idColumn} FROM {$metadata->tableName}";
+        $params = [];
+
+        if (!empty($criteria)) {
+            $conditions = [];
+            foreach ($criteria as $field => $value) {
+                $columnName = $metadata->getColumnName($field);
+                $conditions[] = "{$columnName} = ?";
+                $params[] = $value;
+            }
+            $query .= " WHERE " . implode(' AND ', $conditions);
+        }
+
+        if ($orderBy) {
+            $orderClauses = [];
+            foreach ($orderBy as $field => $direction) {
+                $columnName = $metadata->getColumnName($field);
+                $orderClauses[] = "{$columnName} " . strtoupper($direction);
+            }
+            $query .= " ORDER BY " . implode(', ', $orderClauses);
+        }
+
+        if ($limit) {
+            $query .= " LIMIT {$limit}";
+        }
+
+        $result = $this->databaseManager->getConnection()->query($query, $params);
+
+        $entities = [];
+        foreach ($result->fetchAll() as $data) {
+            $idValue = $data[$metadata->idColumn];
+            $entities[] = $this->find($entityClass, $idValue); // Nutzt lazy loading
+        }
+
+        return $entities;
+    }
+
+    /**
+     * Findet eine Entity nach Kriterien
+     */
+    public function findOneBy(string $entityClass, array $criteria): ?object
+    {
+        $results = $this->findBy($entityClass, $criteria, limit: 1);
+        return $results[0] ?? null;
+    }
+
+    /**
+     * Utility Methods
+     */
+    public function detach(object $entity): void
+    {
+        $metadata = $this->metadataRegistry->getMetadata($entity::class);
+
+        // ID der Entity ermitteln
+        $constructor = $metadata->reflection->getConstructor();
+        if ($constructor) {
+            foreach ($constructor->getParameters() as $param) {
+                $paramName = $param->getName();
+                $propertyMetadata = $metadata->getProperty($paramName);
+
+                if ($propertyMetadata && $propertyMetadata->columnName === $metadata->idColumn) {
+                    try {
+                        $property = $metadata->reflection->getProperty($paramName);
+                        $id = $property->getValue($entity);
+                        $this->identityMap->remove($entity::class, $id);
+                        break;
+                    } catch (\ReflectionException) {
+                        // Property nicht gefunden
+                    }
+                }
+            }
+        }
+    }
+
+    public function clear(): void
+    {
+        $this->identityMap->clear();
+    }
+
+    public function getIdentityMapStats(): array
+    {
+        return $this->identityMap->getStats();
+    }
+
+    public function isLazyGhost(object $entity): bool
+    {
+        return $this->lazyLoader->isLazyGhost($entity);
+    }
+
+    public function initializeLazyObject(object $entity): void
+    {
+        $this->lazyLoader->initializeLazyObject($entity);
+    }
+
+    public function getMetadata(string $entityClass): EntityMetadata
+    {
+        return $this->metadataRegistry->getMetadata($entityClass);
+    }
+
+    /**
+     * Generiert eine einzigartige ID für Entities
+     */
+    public function generateId(): string
+    {
+        return IdGenerator::generate();
+    }
+
+    /**
+     * Speichert eine Entity (INSERT oder UPDATE)
+     */
+    public function save(object $entity): object
+    {
+        $metadata = $this->metadataRegistry->getMetadata($entity::class);
+
+        $idProperty = $metadata->reflection->getProperty($metadata->idProperty);
+        $id = $idProperty->getValue($entity);
+
+        // Prüfe ob Entity bereits existiert
+        if ($this->exists($entity::class, $id)) {
+            return $this->update($entity);
+        } else {
+            return $this->insert($entity);
+        }
+    }
+
+    /**
+     * Prüft ob eine Entity mit der angegebenen ID existiert
+     */
+    public function exists(string $entityClass, mixed $id): bool
+    {
+        $metadata = $this->metadataRegistry->getMetadata($entityClass);
+
+        $query = "SELECT 1 FROM {$metadata->tableName} WHERE {$metadata->idColumn} = ? LIMIT 1";
+        $result = $this->databaseManager->getConnection()->query($query, [$id]);
+
+        return (bool) $result->fetch();
+    }
+
+    /**
+     * Fügt eine neue Entity ein (INSERT)
+     */
+    public function insert(object $entity): object
+    {
+
+
+        $metadata = $this->metadataRegistry->getMetadata($entity::class);
+
+        // Columnnamen und Values sammeln
+        $columns = [];
+        $values = [];
+        $params = [];
+
+        foreach ($metadata->properties as $propertyName => $propertyMetadata) {
+            // ID Property überspringen wenn auto-increment
+            if ($propertyName === $metadata->idProperty && $propertyMetadata->autoIncrement) {
+                continue;
+            }
+
+            // Property-Wert auslesen
+            $property = $metadata->reflection->getProperty($propertyName);
+
+            if(!$property->isInitialized($entity)) {
+                continue;
+            }
+
+
+            $columns[] = $propertyMetadata->columnName;
+            $values[] = '?';
+
+            $params[] = $property->getValue($entity);
+        }
+
+        // INSERT Query bauen
+        $query = "INSERT INTO {$metadata->tableName} (" . implode(', ', $columns) . ") "
+              . "VALUES (" . implode(', ', $values) . ")";
+
+        // Query ausführen
+        $result = $this->databaseManager->getConnection()->execute($query, $params);
+
+        // In Identity Map speichern
+        $idProperty = $metadata->reflection->getProperty($metadata->idProperty);
+        $id = $idProperty->getValue($entity);
+        $this->identityMap->set($entity::class, $id, $entity);
+
+        return $entity;
+    }
+
+    /**
+     * Aktualisiert eine vorhandene Entity (UPDATE)
+     */
+    public function update(object $entity): object
+    {
+        $metadata = $this->metadataRegistry->getMetadata($entity::class);
+
+        // SET-Clause und Params aufbauen
+        $setClause = [];
+        $params = [];
+
+        foreach ($metadata->properties as $propertyName => $propertyMetadata) {
+
+            // Relations beim Update ignorieren
+            if($propertyMetadata->isRelation) {
+                continue;
+            }
+
+            // ID überspringen (wird nicht aktualisiert)
+            if ($propertyName === $metadata->idProperty) {
+                continue;
+            }
+
+            $setClause[] = "{$propertyMetadata->columnName} = ?";
+
+            // Property-Wert auslesen
+            $property = $metadata->reflection->getProperty($propertyName);
+            $params[] = $property->getValue($entity);
+        }
+
+        // ID für WHERE Clause hinzufügen
+        $idProperty = $metadata->reflection->getProperty($metadata->idProperty);
+        $id = $idProperty->getValue($entity);
+        $params[] = $id;
+
+        // UPDATE Query bauen
+        $query = "UPDATE {$metadata->tableName} SET " . implode(', ', $setClause)
+              . " WHERE {$metadata->idColumn} = ?";
+
+        // Query ausführen
+        $result = $this->databaseManager->getConnection()->query($query, $params);
+
+        // Identity Map aktualisieren
+        $this->identityMap->set($entity::class, $id, $entity);
+
+        return $entity;
+    }
+
+    /**
+     * Löscht eine Entity
+     */
+    public function delete(object $entity): void
+    {
+        $metadata = $this->metadataRegistry->getMetadata($entity::class);
+
+        // ID auslesen
+        $idProperty = $metadata->reflection->getProperty($metadata->idProperty);
+        $id = $idProperty->getValue($entity);
+
+        // DELETE Query ausführen
+        $query = "DELETE FROM {$metadata->tableName} WHERE {$metadata->idColumn} = ?";
+        $this->databaseManager->getConnection()->query($query, [$id]);
+
+        // Aus Identity Map entfernen
+        $this->identityMap->remove($entity::class, $id);
+    }
+
+    /**
+     * Speichert mehrere Entities auf einmal
+     */
+    public function saveAll(object ...$entities): array
+    {
+        $result = [];
+        foreach ($entities as $entity) {
+            $result[] = $this->save($entity);
+        }
+        return $result;
+    }
+
+    /**
+     * Führt eine Funktion in einer Transaktion aus
+     */
+    public function transaction(callable $callback): mixed
+    {
+        $connection = $this->databaseManager->getConnection();
+
+        // Wenn bereits in einer Transaktion, führe Callback direkt aus
+        if ($connection->inTransaction()) {
+            return $callback($this);
+        }
+
+        // Neue Transaktion starten
+        $connection->beginTransaction();
+
+        try {
+            $result = $callback($this);
+            $connection->commit();
+            return $result;
+        } catch (\Throwable $e) {
+            $connection->rollback();
+            throw $e;
+        }
+    }
+}
diff --git a/src/Framework/Database/EntityManagerFactory.php b/src/Framework/Database/EntityManagerFactory.php
new file mode 100644
index 00000000..924af6ea
--- /dev/null
+++ b/src/Framework/Database/EntityManagerFactory.php
@@ -0,0 +1,37 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Database;
+
+use App\Framework\Database\Metadata\MetadataExtractor;
+use App\Framework\Database\Metadata\MetadataRegistry;
+use App\Framework\Database\TypeCaster\TypeCasterRegistry;
+
+final class EntityManagerFactory
+{
+    public static function create(DatabaseManager $databaseManager): EntityManager
+    {
+        $metadataExtractor = new MetadataExtractor();
+        $metadataRegistry = new MetadataRegistry($metadataExtractor);
+        $casterRegistry = new TypeCasterRegistry();
+        $typeConverter = new TypeConverter($casterRegistry);
+        #$hydrator = new Hydrator($typeConverter);
+        $identityMap = new IdentityMap();
+
+        $lazyLoader = new LazyLoader(
+            databaseManager: $databaseManager,
+            typeConverter: $typeConverter,
+            identityMap: $identityMap,
+            metadataRegistry: $metadataRegistry
+        );
+
+        return new EntityManager(
+            databaseManager: $databaseManager,
+            metadataRegistry: $metadataRegistry,
+            typeConverter: $typeConverter,
+            identityMap: $identityMap,
+            lazyLoader: $lazyLoader
+        );
+    }
+}
diff --git a/src/Framework/Database/EntityManagerInitializer.php b/src/Framework/Database/EntityManagerInitializer.php
new file mode 100644
index 00000000..b9e81273
--- /dev/null
+++ b/src/Framework/Database/EntityManagerInitializer.php
@@ -0,0 +1,55 @@
+<?php
+
+namespace App\Framework\Database;
+
+use App\Domain\User\User;
+use App\Framework\Attributes\Singleton;
+use App\Framework\Database\Config\DatabaseConfig;
+use App\Framework\Database\Config\PoolConfig;
+use App\Framework\Database\Driver\DriverConfig;
+use App\Framework\Database\Driver\DriverType;
+use App\Framework\DI\Container;
+use App\Framework\DI\Initializer;
+
+final readonly class EntityManagerInitializer
+{
+    #[Initializer]
+    public function __invoke(Container $container): EntityManager
+    {
+        $config = [
+            'driver' => 'mysql',
+            'host' => 'db',
+            'port' => 3306,
+            'username' => 'mdb-user',
+            'password' => 'dfghreh5465fghfgh',
+            'database' => 'database',
+        ];
+
+        $newConfig = new DatabaseConfig(
+            new DriverConfig(
+                driverType: DriverType::MYSQL,
+                host      : 'mysql',
+                port      : 3306,
+                database  : 'database',
+                username  : "mdb-user",
+                password  : 'dfghreh5465fghfgh',
+                charset   : 'utf8mb4',
+            ),
+            new PoolConfig(
+                enabled: true,
+                maxConnections: 5,
+                minConnections: 2,
+            ),
+        );
+
+
+        #$connection = DatabaseFactory::createConnection($config);
+
+        $db = new DatabaseManager($config);
+
+        $container->singleton(DatabaseManager::class, $db);
+        $container->singleton(ConnectionInterface::class, $db->getConnection());
+
+        return EntityManagerFactory::create($db);
+    }
+}
diff --git a/src/Framework/Database/Example/README.md b/src/Framework/Database/Example/README.md
new file mode 100644
index 00000000..be4a1728
--- /dev/null
+++ b/src/Framework/Database/Example/README.md
@@ -0,0 +1,69 @@
+# Entity-Framework Beispiele
+
+## Nutzung der ID-Generierung
+
+Beispiele für das Speichern und Abrufen von Entities mit automatisch generierten IDs.
+
+```php
+// Neue Entity erstellen - ID wird automatisch generiert
+$user = new User('Max Mustermann', 'max@example.com');
+echo $user->id; // generierte ID, z.B. "7a3b9c2d1e4f5a6b8c9d0e1f2a3b4c5d"
+
+// Entity speichern
+$entityManager->save($user);
+
+// Entity finden
+$foundUser = $entityManager->find(User::class, $user->id);
+
+// Entity aktualisieren (immutable update pattern)
+$updatedUser = $foundUser->withName('Maximilian Mustermann');
+$entityManager->save($updatedUser);
+```
+
+## Repository-Beispiele
+
+```php
+// Repository erstellen
+$userRepository = new UserRepository($entityManager);
+
+// Neuen User erstellen
+$user = $userRepository->create('Anna Schmidt', 'anna@example.com');
+
+// User suchen
+$annaUser = $userRepository->findByEmail('anna@example.com');
+
+// User aktualisieren
+$updatedUser = $userRepository->changeName($annaUser, 'Anna Müller');
+
+// User löschen
+$userRepository->delete($updatedUser);
+```
+
+## Transaktionen
+
+```php
+$result = $entityManager->transaction(function($em) {
+    $user1 = new User('User 1', 'user1@example.com');
+    $user2 = new User('User 2', 'user2@example.com');
+
+    $em->save($user1);
+    $em->save($user2);
+
+    return [$user1, $user2];
+});
+```
+
+## Entity-Beziehungen (kommt später)
+
+```php
+// One-to-Many Beziehung
+$post = new Post('Titel', 'Inhalt', $user->id);
+$entityManager->save($post);
+
+// Many-to-Many Beziehung (später)
+$tag = new Tag('php');
+$entityManager->save($tag);
+
+$postTag = new PostTag($post->id, $tag->id);
+$entityManager->save($postTag);
+```
diff --git a/src/Framework/Database/Example/UserEntity.php b/src/Framework/Database/Example/UserEntity.php
new file mode 100644
index 00000000..aee4f964
--- /dev/null
+++ b/src/Framework/Database/Example/UserEntity.php
@@ -0,0 +1,51 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Database\Example;
+
+use App\Framework\Database\Attributes\Entity;
+use App\Framework\Database\Attributes\Column;
+use App\Framework\Database\IdGenerator;
+
+/**
+ * Beispiel-Entity mit auto-generierter ID
+ */
+#[Entity('users')]
+final readonly class User
+{
+    #[Column(name: 'id', primary: true)]
+    public string $id;
+
+    #[Column(name: 'name')]
+    public string $name;
+
+    #[Column(name: 'email')]
+    public ?string $email;
+
+    public function __construct(
+        string $name,
+        ?string $email = null,
+        ?string $id = null
+    ) {
+        $this->id = $id ?? IdGenerator::generate();
+        $this->name = $name;
+        $this->email = $email;
+    }
+
+    /**
+     * Erstellt eine neue Instanz mit geändertem Namen
+     */
+    public function withName(string $name): self
+    {
+        return new self($name, $this->email, $this->id);
+    }
+
+    /**
+     * Erstellt eine neue Instanz mit geänderter Email
+     */
+    public function withEmail(?string $email): self
+    {
+        return new self($this->name, $email, $this->id);
+    }
+}
diff --git a/src/Framework/Database/Example/UserRepository.php b/src/Framework/Database/Example/UserRepository.php
new file mode 100644
index 00000000..bbb79af2
--- /dev/null
+++ b/src/Framework/Database/Example/UserRepository.php
@@ -0,0 +1,50 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Database\Example;
+
+use App\Framework\Database\Repository\EntityRepository;
+
+/**
+ * Beispiel für Repository mit User-Entity
+ */
+final class UserRepository extends EntityRepository
+{
+    protected string $entityClass = User::class;
+
+    /**
+     * Findet User nach Email
+     */
+    public function findByEmail(string $email): ?User
+    {
+        return $this->findOneBy(['email' => $email]);
+    }
+
+    /**
+     * Erstellt einen neuen User
+     */
+    public function create(string $name, ?string $email = null): User
+    {
+        $user = new User($name, $email);
+        return $this->save($user);
+    }
+
+    /**
+     * Ändert den Namen eines Users
+     */
+    public function changeName(User $user, string $newName): User
+    {
+        $updatedUser = $user->withName($newName);
+        return $this->save($updatedUser);
+    }
+
+    /**
+     * Ändert die Email eines Users
+     */
+    public function changeEmail(User $user, ?string $newEmail): User
+    {
+        $updatedUser = $user->withEmail($newEmail);
+        return $this->save($updatedUser);
+    }
+}
diff --git a/src/Framework/Database/Exception/DatabaseException.php b/src/Framework/Database/Exception/DatabaseException.php
new file mode 100644
index 00000000..dccd4c26
--- /dev/null
+++ b/src/Framework/Database/Exception/DatabaseException.php
@@ -0,0 +1,9 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Database\Exception;
+
+class DatabaseException extends \Exception
+{
+}
diff --git a/src/Framework/Database/Exception/EntityNotFoundException.php b/src/Framework/Database/Exception/EntityNotFoundException.php
new file mode 100644
index 00000000..28a9983d
--- /dev/null
+++ b/src/Framework/Database/Exception/EntityNotFoundException.php
@@ -0,0 +1,13 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Database\Exception;
+
+class EntityNotFoundException extends DatabaseException
+{
+    public function __construct(string $entityClass, mixed $id, ?\Throwable $previous = null)
+    {
+        parent::__construct("Entity {$entityClass} with ID {$id} not found", 0, $previous);
+    }
+}
diff --git a/src/Framework/Database/HealthCheck/ConnectionHealthChecker.php b/src/Framework/Database/HealthCheck/ConnectionHealthChecker.php
new file mode 100644
index 00000000..1440acd9
--- /dev/null
+++ b/src/Framework/Database/HealthCheck/ConnectionHealthChecker.php
@@ -0,0 +1,233 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Database\HealthCheck;
+
+use App\Framework\Database\ConnectionInterface;
+use App\Framework\Database\Exception\DatabaseException;
+
+final readonly class ConnectionHealthChecker
+{
+    public function __construct(
+        private int $timeoutSeconds = 5,
+        private array $customQueries = []
+    ) {}
+
+    /**
+     * Führt einen einfachen Health Check aus
+     */
+    public function checkHealth(ConnectionInterface $connection): HealthCheckResult
+    {
+        $startTime = microtime(true);
+
+        try {
+            // Einfacher SELECT zum Testen der Verbindung
+            $result = $connection->queryScalar('SELECT 1');
+
+            $responseTime = (microtime(true) - $startTime) * 1000; // in Millisekunden
+
+            if ($result != 1) {
+                return HealthCheckResult::unhealthy(
+                    $responseTime,
+                    'Unexpected result from health check query',
+                    null,
+                    ['expected' => 1, 'actual' => $result]
+                );
+            }
+
+            return HealthCheckResult::healthy($responseTime, 'Connection is healthy');
+
+        } catch (\Throwable $e) {
+            $responseTime = (microtime(true) - $startTime) * 1000;
+            return HealthCheckResult::error($e, $responseTime);
+        }
+    }
+
+    /**
+     * Führt einen Health Check mit Timeout aus
+     */
+    public function checkHealthWithTimeout(ConnectionInterface $connection): HealthCheckResult
+    {
+        $startTime = time();
+
+        while ((time() - $startTime) < $this->timeoutSeconds) {
+            $result = $this->checkHealth($connection);
+
+            if ($result->isHealthy) {
+                return $result;
+            }
+
+            // Kurz warten vor nächstem Versuch
+            usleep(100000); // 100ms
+        }
+
+        return HealthCheckResult::timeout($this->timeoutSeconds * 1000);
+    }
+
+    /**
+     * Führt erweiterte Health Checks aus
+     */
+    public function checkDetailedHealth(ConnectionInterface $connection): HealthCheckResult
+    {
+        $startTime = microtime(true);
+        $additionalData = [];
+
+        try {
+            // 1. Basis Health Check
+            $basicResult = $this->checkHealth($connection);
+            if (!$basicResult->isHealthy) {
+                return $basicResult;
+            }
+
+            $additionalData['basic_check'] = $basicResult->toArray();
+
+            // 2. PDO-Status prüfen
+            $pdoStatus = $this->checkPdoStatus($connection);
+            $additionalData['pdo_status'] = $pdoStatus;
+
+            // 3. Custom Queries ausführen
+            if (!empty($this->customQueries)) {
+                $customResults = $this->executeCustomQueries($connection);
+                $additionalData['custom_queries'] = $customResults;
+            }
+
+            // 4. Connection Attributes prüfen
+            $attributes = $this->getConnectionAttributes($connection);
+            $additionalData['connection_attributes'] = $attributes;
+
+            $responseTime = (microtime(true) - $startTime) * 1000;
+
+            return HealthCheckResult::healthy(
+                $responseTime,
+                'Detailed health check passed',
+                $additionalData
+            );
+
+        } catch (\Throwable $e) {
+            $responseTime = (microtime(true) - $startTime) * 1000;
+            return HealthCheckResult::error($e, $responseTime)->withAdditionalData('partial_data', $additionalData);
+        }
+    }
+
+    /**
+     * Prüft ob die Connection noch lebendig ist (schneller Check)
+     */
+    public function checkConnectionAlive(ConnectionInterface $connection): bool
+    {
+        try {
+            $pdo = $connection->getPdo();
+
+            // Prüfe ob die PDO-Verbindung noch aktiv ist
+            $stmt = $pdo->query('SELECT 1');
+            return $stmt !== false;
+
+        } catch (\Throwable) {
+            return false;
+        }
+    }
+
+    /**
+     * Prüft den PDO-Status
+     */
+    private function checkPdoStatus(ConnectionInterface $connection): array
+    {
+        try {
+            $pdo = $connection->getPdo();
+
+            return [
+                'connection_status' => $pdo->getAttribute(\PDO::ATTR_CONNECTION_STATUS),
+                'server_info' => $pdo->getAttribute(\PDO::ATTR_SERVER_INFO),
+                'driver_name' => $pdo->getAttribute(\PDO::ATTR_DRIVER_NAME),
+                'client_version' => $pdo->getAttribute(\PDO::ATTR_CLIENT_VERSION),
+                'server_version' => $pdo->getAttribute(\PDO::ATTR_SERVER_VERSION),
+                'in_transaction' => $connection->inTransaction(),
+            ];
+        } catch (\Throwable $e) {
+            return ['error' => $e->getMessage()];
+        }
+    }
+
+    /**
+     * Führt benutzerdefinierte Queries aus
+     */
+    private function executeCustomQueries(ConnectionInterface $connection): array
+    {
+        $results = [];
+
+        foreach ($this->customQueries as $name => $query) {
+            try {
+                $startTime = microtime(true);
+                $result = $connection->queryScalar($query);
+                $responseTime = (microtime(true) - $startTime) * 1000;
+
+                $results[$name] = [
+                    'success' => true,
+                    'result' => $result,
+                    'response_time_ms' => round($responseTime, 2),
+                ];
+            } catch (\Throwable $e) {
+                $results[$name] = [
+                    'success' => false,
+                    'error' => $e->getMessage(),
+                    'response_time_ms' => 0,
+                ];
+            }
+        }
+
+        return $results;
+    }
+
+    /**
+     * Sammelt Connection-Attribute
+     */
+    private function getConnectionAttributes(ConnectionInterface $connection): array
+    {
+        try {
+            $pdo = $connection->getPdo();
+
+            $attributes = [];
+            $attributesToCheck = [
+                'AUTOCOMMIT' => \PDO::ATTR_AUTOCOMMIT,
+                'ERRMODE' => \PDO::ATTR_ERRMODE,
+                'CASE' => \PDO::ATTR_CASE,
+                'NULL_TO_STRING' => \PDO::ATTR_NULL_TO_STRING,
+                'STRINGIFY_FETCHES' => \PDO::ATTR_STRINGIFY_FETCHES,
+                'STATEMENT_CLASS' => \PDO::ATTR_STATEMENT_CLASS,
+                'TIMEOUT' => \PDO::ATTR_TIMEOUT,
+                'EMULATE_PREPARES' => \PDO::ATTR_EMULATE_PREPARES,
+                'DEFAULT_FETCH_MODE' => \PDO::ATTR_DEFAULT_FETCH_MODE,
+            ];
+
+            foreach ($attributesToCheck as $name => $constant) {
+                try {
+                    $attributes[$name] = $pdo->getAttribute($constant);
+                } catch (\Throwable) {
+                    $attributes[$name] = 'Not supported';
+                }
+            }
+
+            return $attributes;
+        } catch (\Throwable $e) {
+            return ['error' => $e->getMessage()];
+        }
+    }
+
+    /**
+     * Factory-Methoden für verschiedene Health Check-Konfigurationen
+     */
+    public static function quick(int $timeoutSeconds = 2): self
+    {
+        return new self($timeoutSeconds);
+    }
+
+    public static function detailed(int $timeoutSeconds = 10, array $customQueries = []): self
+    {
+        return new self($timeoutSeconds, $customQueries);
+    }
+
+    public static function withCustomQueries(array $customQueries, int $timeoutSeconds = 5): self
+    {
+        return new self($timeoutSeconds, $customQueries);
+    }
+}
diff --git a/src/Framework/Database/HealthCheck/HealthCheckResult.php b/src/Framework/Database/HealthCheck/HealthCheckResult.php
new file mode 100644
index 00000000..0f451c61
--- /dev/null
+++ b/src/Framework/Database/HealthCheck/HealthCheckResult.php
@@ -0,0 +1,75 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Database\HealthCheck;
+
+final readonly class HealthCheckResult
+{
+    public function __construct(
+        public bool $isHealthy,
+        public float $responseTimeMs,
+        public ?string $message = null,
+        public ?\Throwable $exception = null,
+        public array $additionalData = []
+    ) {}
+
+    public function toArray(): array
+    {
+        return [
+            'healthy' => $this->isHealthy,
+            'response_time_ms' => round($this->responseTimeMs, 2),
+            'message' => $this->message,
+            'error' => $this->exception?->getMessage(),
+            'error_code' => $this->exception?->getCode(),
+            'additional_data' => $this->additionalData,
+            'timestamp' => time(),
+        ];
+    }
+
+    public function toJson(): string
+    {
+        return json_encode($this->toArray(), JSON_THROW_ON_ERROR);
+    }
+
+    public function withAdditionalData(string $key, mixed $value): self
+    {
+        return new self(
+            $this->isHealthy,
+            $this->responseTimeMs,
+            $this->message,
+            $this->exception,
+            array_merge($this->additionalData, [$key => $value])
+        );
+    }
+
+    public function getAdditionalData(string $key, mixed $default = null): mixed
+    {
+        return $this->additionalData[$key] ?? $default;
+    }
+
+    public function hasAdditionalData(string $key): bool
+    {
+        return array_key_exists($key, $this->additionalData);
+    }
+
+    public static function healthy(float $responseTimeMs, ?string $message = null, array $additionalData = []): self
+    {
+        return new self(true, $responseTimeMs, $message, null, $additionalData);
+    }
+
+    public static function unhealthy(float $responseTimeMs, string $message, ?\Throwable $exception = null, array $additionalData = []): self
+    {
+        return new self(false, $responseTimeMs, $message, $exception, $additionalData);
+    }
+
+    public static function timeout(float $timeoutMs): self
+    {
+        return self::unhealthy($timeoutMs, "Health check timed out after {$timeoutMs}ms");
+    }
+
+    public static function error(\Throwable $exception, float $responseTimeMs = 0): self
+    {
+        return self::unhealthy($responseTimeMs, $exception->getMessage(), $exception);
+    }
+}
diff --git a/src/Framework/Database/HealthCheck/HealthCheckScheduler.php b/src/Framework/Database/HealthCheck/HealthCheckScheduler.php
new file mode 100644
index 00000000..2b2ff2d7
--- /dev/null
+++ b/src/Framework/Database/HealthCheck/HealthCheckScheduler.php
@@ -0,0 +1,162 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Database\HealthCheck;
+
+use App\Framework\Database\ConnectionInterface;
+
+final class HealthCheckScheduler
+{
+    private array $healthChecks = [];
+    private array $lastResults = [];
+
+    public function __construct(
+        private readonly ConnectionHealthChecker $healthChecker
+    ) {}
+
+    /**
+     * Registriert einen Health Check
+     */
+    public function registerHealthCheck(
+        string $name,
+        ConnectionInterface $connection,
+        int $intervalSeconds = 30,
+        bool $detailed = false
+    ): self {
+        $this->healthChecks[$name] = [
+            'connection' => $connection,
+            'interval' => $intervalSeconds,
+            'detailed' => $detailed,
+            'last_check' => 0,
+        ];
+
+        return $this;
+    }
+
+    /**
+     * Führt alle fälligen Health Checks aus
+     */
+    public function runScheduledChecks(): array
+    {
+        $results = [];
+        $currentTime = time();
+
+        foreach ($this->healthChecks as $name => $config) {
+            if (($currentTime - $config['last_check']) >= $config['interval']) {
+                $result = $this->runHealthCheck($name, $config);
+                $results[$name] = $result;
+
+                $this->lastResults[$name] = $result;
+                $this->healthChecks[$name]['last_check'] = $currentTime;
+            }
+        }
+
+        return $results;
+    }
+
+    /**
+     * Führt einen spezifischen Health Check aus
+     */
+    public function runHealthCheck(string $name, ?array $config = null): HealthCheckResult
+    {
+        $config = $config ?? $this->healthChecks[$name] ?? null;
+
+        if (!$config) {
+            return HealthCheckResult::error(
+                new \InvalidArgumentException("Health check '{$name}' not found")
+            );
+        }
+
+        try {
+            if ($config['detailed']) {
+                return $this->healthChecker->checkDetailedHealth($config['connection']);
+            } else {
+                return $this->healthChecker->checkHealth($config['connection']);
+            }
+        } catch (\Throwable $e) {
+            return HealthCheckResult::error($e);
+        }
+    }
+
+    /**
+     * Gibt alle letzten Health Check-Ergebnisse zurück
+     */
+    public function getAllResults(): array
+    {
+        return $this->lastResults;
+    }
+
+    /**
+     * Gibt das letzte Ergebnis für einen spezifischen Health Check zurück
+     */
+    public function getLastResult(string $name): ?HealthCheckResult
+    {
+        return $this->lastResults[$name] ?? null;
+    }
+
+    /**
+     * Prüft ob alle registrierten Connections gesund sind
+     */
+    public function areAllHealthy(): bool
+    {
+        foreach ($this->lastResults as $result) {
+            if (!$result->isHealthy) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    /**
+     * Gibt eine Zusammenfassung aller Health Checks zurück
+     */
+    public function getSummary(): array
+    {
+        $total = count($this->healthChecks);
+        $healthy = 0;
+        $unhealthy = 0;
+        $unknown = 0;
+
+        foreach ($this->healthChecks as $name => $config) {
+            if (isset($this->lastResults[$name])) {
+                if ($this->lastResults[$name]->isHealthy) {
+                    $healthy++;
+                } else {
+                    $unhealthy++;
+                }
+            } else {
+                $unknown++;
+            }
+        }
+
+        return [
+            'total_checks' => $total,
+            'healthy' => $healthy,
+            'unhealthy' => $unhealthy,
+            'unknown' => $unknown,
+            'overall_status' => $unhealthy === 0 ? 'healthy' : 'unhealthy',
+            'last_updated' => time(),
+        ];
+    }
+
+    /**
+     * Entfernt einen Health Check
+     */
+    public function unregisterHealthCheck(string $name): self
+    {
+        unset($this->healthChecks[$name], $this->lastResults[$name]);
+        return $this;
+    }
+
+    /**
+     * Löscht alle Health Checks
+     */
+    public function clear(): self
+    {
+        $this->healthChecks = [];
+        $this->lastResults = [];
+        return $this;
+    }
+}
diff --git a/src/Framework/Database/Hydrator.php b/src/Framework/Database/Hydrator.php
new file mode 100644
index 00000000..4fd6d11a
--- /dev/null
+++ b/src/Framework/Database/Hydrator.php
@@ -0,0 +1,156 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Database;
+
+use App\Framework\Database\Exception\DatabaseException;
+use App\Framework\Database\Metadata\EntityMetadata;
+use App\Framework\Database\Metadata\PropertyMetadata;
+
+final readonly class Hydrator
+{
+    public function __construct(
+        private TypeConverter $typeConverter,
+        private EntityManager $entityManager,
+    ) {}
+
+    public function hydrate(EntityMetadata $metadata, array $data): object
+    {
+        try {
+            $constructor = $metadata->reflection->getConstructor();
+
+            if (!$constructor) {
+                throw new DatabaseException("Entity {$metadata->entityClass} must have a constructor");
+            }
+
+            $constructorParams = [];
+            foreach ($constructor->getParameters() as $param) {
+                $paramName = $param->getName();
+                $propertyMetadata = $metadata->getProperty($paramName);
+
+                if (!$propertyMetadata) {
+                    throw new DatabaseException("No metadata found for parameter {$paramName}");
+                }
+
+                $columnName = $propertyMetadata->columnName;
+                $value = $data[$columnName] ?? null;
+
+                // Typ-Konvertierung
+                $value = $this->typeConverter->convertValue($value, $propertyMetadata);
+
+                $constructorParams[] = $value;
+            }
+
+            $entity = new $metadata->entityClass(...$constructorParams);
+
+            $this->hydrateRelations($entity, $metadata, $data);
+
+            return $entity;
+
+
+        } catch (\ReflectionException $e) {
+            throw new DatabaseException("Failed to create entity {$metadata->entityClass}: {$e->getMessage()}", 0, $e);
+        }
+    }
+
+    private function hydrateRelations(object $entity, EntityMetadata $metadata, array $data): void
+    {
+
+        foreach ($metadata->properties as $propertyMetadata) {
+            if (!$propertyMetadata->isRelation) {
+                continue;
+            }
+
+            $relationValue = $this->loadRelation($propertyMetadata, $data);
+
+            if ($relationValue !== null) {
+                $this->setProperty($entity, $propertyMetadata->name, $relationValue);
+            }
+        }
+    }
+
+    private function loadRelation(PropertyMetadata $propertyMetadata, array $data): mixed
+    {
+        $keyValue = $this->getRelationKeyValue($propertyMetadata, $data);
+
+        if($keyValue === null) {
+            return $this->getDefaultRelationValue($propertyMetadata);
+        }
+
+        switch($propertyMetadata->relationType) {
+            case 'one-to-one':
+                return $this->loadOneToOneRelation($propertyMetadata, $keyValue);
+            case 'hasMany':
+                return $this->loadHasManyRelation($propertyMetadata, $keyValue);
+            case 'belongsTo':
+                return $this->loadBelongsToRelation($propertyMetadata, $keyValue);
+            default:
+                 throw new DatabaseException("Unknown relation type {$propertyMetadata->relationType}");
+        }
+    }
+
+    private function getRelationKeyValue(PropertyMetadata $propertyMetadata, array $data): mixed
+    {
+        return match($propertyMetadata->relationType) {
+            'one-to-one' => $data[$propertyMetadata->relationLocalKey] ?? null,
+            'hasMany' => $data[$propertyMetadata->relationLocalKey] ?? null,
+            'belongsTo' => $data[$propertyMetadata->relationForeignKey] ?? null,
+            default => null
+        };
+    }
+
+    private function loadOneToOneRelation(PropertyMetadata $propertyMetadata, mixed $localKeyValue):?object
+    {
+        return $this->entityManager->findOneBy(
+            $propertyMetadata->relationTargetClass,
+            [$this->getForeignKeyPropertyName($propertyMetadata) => $localKeyValue]
+        );
+    }
+
+    private function loadHasManyRelation(PropertyMetadata $propertyMetadata, mixed $localKeyValue): array
+    {
+        return $this->entityManager->findBy(
+            $propertyMetadata->relationTargetClass,
+            [$this->getForeignKeyPropertyName($propertyMetadata) => $localKeyValue]
+        );
+    }
+
+    private function loadBelongsToRelation(PropertyMetadata $propertyMetadata, mixed $foreignKeyValue):?object
+    {
+        if($foreignKeyValue === null) {
+            return null;
+        }
+
+        return $this->entityManager->find(
+            $propertyMetadata->relationTargetClass,
+            $foreignKeyValue
+        );
+    }
+
+    private function getForeignKeyPropertyName(PropertyMetadata $propertyMetadata): string
+    {
+        return $propertyMetadata->relationForeignKey;
+    }
+
+    private function getDefaultRelationValue(PropertyMetadata $propertyMetadata): mixed
+    {
+        return match($propertyMetadata->relationType) {
+            'one-to-one' => null,
+            'hasMany' => [],
+            'belongsTo' => null,
+            default => null
+        };
+    }
+
+
+    private function setProperty(object $entity, string $propertyName, mixed $value): void
+    {
+        $reflection = new \ReflectionClass($entity);
+        $property = $reflection->getProperty($propertyName);
+
+        // Property zugänglich machen (falls private/protected)
+        $property->setValue($entity, $value);
+    }
+
+}
diff --git a/src/Framework/Database/IdGenerator.php b/src/Framework/Database/IdGenerator.php
new file mode 100644
index 00000000..be8463a5
--- /dev/null
+++ b/src/Framework/Database/IdGenerator.php
@@ -0,0 +1,27 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Database;
+
+/**
+ * Generator für eindeutige Entity-IDs
+ */
+final class IdGenerator
+{
+    /**
+     * Generiert eine zufällige ID
+     */
+    public static function generate(): string
+    {
+        return bin2hex(random_bytes(16)); // 32 character hex string
+    }
+
+    /**
+     * Prüft ob eine ID gültig ist
+     */
+    public static function isValid(string $id): bool
+    {
+        return strlen($id) === 32 && ctype_xdigit($id);
+    }
+}
diff --git a/src/Framework/Database/IdentityMap.php b/src/Framework/Database/IdentityMap.php
new file mode 100644
index 00000000..30d3a230
--- /dev/null
+++ b/src/Framework/Database/IdentityMap.php
@@ -0,0 +1,59 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Database;
+
+/**
+ * IdentityMap is a pattern implementation that provides a way to manage
+ * and track instances of entities by their unique identifiers within a single context.
+ * It helps prevent duplicate instances of the same entity in memory.
+ */
+final class IdentityMap
+{
+    private array $entities = [];
+
+    public function get(string $entityClass, mixed $id): ?object
+    {
+        $key = $this->createKey($entityClass, $id);
+        return $this->entities[$key] ?? null;
+    }
+
+    public function set(string $entityClass, mixed $id, object $entity): void
+    {
+        $key = $this->createKey($entityClass, $id);
+        $this->entities[$key] = $entity;
+    }
+
+    public function has(string $entityClass, mixed $id): bool
+    {
+        $key = $this->createKey($entityClass, $id);
+        return isset($this->entities[$key]);
+    }
+
+    public function remove(string $entityClass, mixed $id): void
+    {
+        $key = $this->createKey($entityClass, $id);
+        unset($this->entities[$key]);
+    }
+
+    public function clear(): void
+    {
+        $this->entities = [];
+    }
+
+    public function getStats(): array
+    {
+        return [
+            'total_entities' => count($this->entities),
+            'entity_types' => array_count_values(
+                array_map(fn($key) => explode('#', $key)[0], array_keys($this->entities))
+            )
+        ];
+    }
+
+    private function createKey(string $entityClass, mixed $id): string
+    {
+        return $entityClass . '#' . $id;
+    }
+}
diff --git a/src/Framework/Database/LazyConnectionFactory.php b/src/Framework/Database/LazyConnectionFactory.php
new file mode 100644
index 00000000..f51ed670
--- /dev/null
+++ b/src/Framework/Database/LazyConnectionFactory.php
@@ -0,0 +1,90 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Database;
+
+use App\Framework\Database\Driver\DriverConfig;
+use App\Framework\Database\Exception\DatabaseException;
+use ReflectionClass;
+
+final readonly class LazyConnectionFactory
+{
+    public static function createLazyGhost(
+        array|DriverConfig $config,
+        string $connectionClass = PdoConnection::class
+    ): ConnectionInterface {
+        $reflection = new ReflectionClass($connectionClass);
+
+        // Stelle sicher, dass die Klasse ConnectionInterface implementiert
+        if (!$reflection->implementsInterface(ConnectionInterface::class)) {
+            throw new DatabaseException(
+                "Class {$connectionClass} must implement ConnectionInterface"
+            );
+        }
+
+        // Erstelle LazyGhost mit Initializer
+        $ghost = $reflection->newLazyGhost(
+            initializer: function (object $object) use ($config, $connectionClass): void {
+                self::initializeLazyConnection($object, $config, $connectionClass);
+            }
+        );
+
+        return $ghost;
+    }
+
+    private static function initializeLazyConnection(
+        object $ghost,
+        array|DriverConfig $config,
+        string $connectionClass
+    ): void {
+        // Erstelle die echte Verbindung
+        $realConnection = DatabaseFactory::createDirectConnection($config);
+
+        // Kopiere alle Properties von der echten Verbindung in das Ghost
+        $ghostReflection = new ReflectionClass($ghost);
+        $realReflection = new ReflectionClass($realConnection);
+
+        // Für PdoConnection: kopiere die PDO-Instanz
+        if ($realConnection instanceof PdoConnection) {
+            $pdoProperty = $realReflection->getProperty('pdo');
+            $ghostPdoProperty = $ghostReflection->getProperty('pdo');
+
+            $ghostPdoProperty->setValue($ghost, $pdoProperty->getValue($realConnection));
+        }
+
+        // Zusätzliche Properties falls vorhanden
+        foreach ($realReflection->getProperties() as $property) {
+            if ($ghostReflection->hasProperty($property->getName())) {
+                $ghostProperty = $ghostReflection->getProperty($property->getName());
+                $ghostProperty->setValue($ghost, $property->getValue($realConnection));
+            }
+        }
+    }
+
+    public static function isLazyGhost(object $object): bool
+    {
+        $reflection = new ReflectionClass($object);
+        return $reflection->isUninitializedLazyObject($object);
+    }
+
+    public static function initializeLazyGhost(object $object): void
+    {
+        $reflection = new ReflectionClass($object);
+        if ($reflection->isUninitializedLazyObject($object)) {
+            $reflection->initializeLazyObject($object);
+        }
+    }
+
+    public static function resetLazyGhost(object $object): void
+    {
+        $reflection = new ReflectionClass($object);
+        if (!$reflection->isUninitializedLazyObject($object)) {
+            $reflection->resetAsLazyGhost($object, function (object $obj) use ($object): void {
+                // Re-initialize with same logic as original
+                // This would require storing the original config somewhere
+                throw new DatabaseException('LazyGhost reset requires stored configuration');
+            });
+        }
+    }
+}
diff --git a/src/Framework/Database/LazyLoader.php b/src/Framework/Database/LazyLoader.php
new file mode 100644
index 00000000..d399e002
--- /dev/null
+++ b/src/Framework/Database/LazyLoader.php
@@ -0,0 +1,385 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Database;
+
+use App\Framework\Database\Metadata\EntityMetadata;
+use App\Framework\Database\Metadata\MetadataRegistry;
+use ReflectionClass;
+
+final readonly class LazyLoader
+{
+    public function __construct(
+        private DatabaseManager $databaseManager,
+        private TypeConverter $typeConverter,
+        private IdentityMap $identityMap,
+        private MetadataRegistry $metadataRegistry
+    ) {}
+
+    /**
+     * Erstellt ein Lazy Ghost Object mit dynamischen Relationen
+     */
+    public function createLazyGhost(EntityMetadata $metadata, mixed $id): object
+    {
+        // Prüfe zuerst Identity Map
+        if ($this->identityMap->has($metadata->entityClass, $id)) {
+            return $this->identityMap->get($metadata->entityClass, $id);
+        }
+
+        $reflection = $metadata->reflection;
+
+        // Für readonly Klassen müssen wir newLazyProxy verwenden
+        if ($reflection->isReadOnly()) {
+            return $this->createLazyProxy($metadata, $id);
+        }
+
+        // Erstelle Lazy Ghost mit dynamischen Relationen
+        $ghost = $reflection->newLazyGhost(
+            initializer: function (object $object) use ($metadata, $id): void {
+                $this->initializeGhostWithDynamicRelations($object, $metadata, $id);
+            }
+        );
+
+        // In Identity Map speichern
+        $this->identityMap->set($metadata->entityClass, $id, $ghost);
+
+        return $ghost;
+    }
+
+    /**
+     * Erstellt einen Lazy Proxy für readonly Klassen
+     */
+    private function createLazyProxy(EntityMetadata $metadata, mixed $id): object
+    {
+        $reflection = $metadata->reflection;
+
+        $proxy = $reflection->newLazyProxy(
+            factory: function () use ($metadata, $id): object {
+                return $this->loadEntityWithDynamicRelations($metadata, $id);
+            }
+        );
+
+        // In Identity Map speichern
+        $this->identityMap->set($metadata->entityClass, $id, $proxy);
+
+        return $proxy;
+    }
+
+    /**
+     * Lädt eine Entity mit dynamischen Relationen
+     */
+    private function loadEntityWithDynamicRelations(EntityMetadata $metadata, mixed $id): object
+    {
+        // Basis-Entity laden
+        $entity = $this->loadEntity($metadata, $id);
+
+        // Dynamische Relationen laden
+        $this->loadDynamicRelations($entity, $metadata, $id);
+
+        return $entity;
+    }
+
+    /**
+     * Initialisiert das Ghost Object mit dynamischen Relationen
+     */
+    private function initializeGhostWithDynamicRelations(object $ghost, EntityMetadata $metadata, mixed $id): void
+    {
+        // Basis-Daten laden
+        $this->initializeGhost($ghost, $metadata, $id);
+
+        // Dynamische Relationen laden
+        $this->loadDynamicRelations($ghost, $metadata, $id);
+    }
+
+    /**
+     * Lädt alle definierten Relationen dynamisch basierend auf Attributen
+     */
+    private function loadDynamicRelations(object $entity, EntityMetadata $metadata, mixed $id): void
+    {
+        foreach ($metadata->properties as $propertyName => $propertyMetadata) {
+            if (!$propertyMetadata->isRelation) {
+                continue;
+            }
+
+            $this->loadRelation($entity, $propertyMetadata, $id);
+        }
+    }
+
+    /**
+     * Lädt eine spezifische Relation basierend auf dem Relation-Typ
+     */
+    private function loadRelation(object $entity, $propertyMetadata, mixed $localKeyValue): void
+    {
+        try {
+            $reflection = new ReflectionClass($entity);
+            $property = $reflection->getProperty($propertyMetadata->name);
+
+            // Relation nur laden wenn noch nicht initialisiert
+            if (!$property->isInitialized($entity)) {
+                $relationValue = $this->loadRelationByType($propertyMetadata, $entity, $localKeyValue);
+                $property->setValue($entity, $relationValue);
+            }
+        } catch (\ReflectionException $e) {
+            // Property nicht vorhanden oder nicht zugänglich
+        }
+    }
+
+    /**
+     * Lädt Relation basierend auf dem Typ
+     */
+    private function loadRelationByType($propertyMetadata, object $entity, mixed $localKeyValue): mixed
+    {
+        switch ($propertyMetadata->relationType) {
+            case 'belongsTo':
+                return $this->loadBelongsToRelation($propertyMetadata, $entity);
+                
+            case 'hasMany':
+                return $this->loadHasManyRelation($propertyMetadata, $localKeyValue);
+                
+            case 'one-to-one':
+                return $this->loadOneToOneRelation($propertyMetadata, $localKeyValue);
+                
+            default:
+                return null;
+        }
+    }
+
+    /**
+     * Lädt eine belongsTo Relation
+     */
+    private function loadBelongsToRelation($propertyMetadata, object $entity): ?object
+    {
+        // Für belongsTo müssen wir den Foreign Key Wert aus der Entity selbst holen
+        $entityMetadata = $this->metadataRegistry->getMetadata($entity::class);
+        
+        // Lade zuerst die Entity-Daten aus der DB, um den Foreign Key zu bekommen
+        $query = "SELECT * FROM {$entityMetadata->tableName} WHERE {$entityMetadata->idColumn} = ?";
+        $entityId = $this->getEntityId($entity, $entityMetadata);
+        
+        $result = $this->databaseManager->getConnection()->query($query, [$entityId]);
+        $data = $result->fetch();
+        
+        if (!$data) {
+            return null;
+        }
+        
+        // Hole den Foreign Key Wert
+        $foreignKeyValue = $data[$propertyMetadata->relationForeignKey] ?? null;
+        
+        if ($foreignKeyValue === null) {
+            return null;
+        }
+        
+        // Lade die verknüpfte Entity
+        $targetMetadata = $this->metadataRegistry->getMetadata($propertyMetadata->relationTargetClass);
+        
+        if ($this->identityMap->has($propertyMetadata->relationTargetClass, $foreignKeyValue)) {
+            return $this->identityMap->get($propertyMetadata->relationTargetClass, $foreignKeyValue);
+        }
+        
+        $query = "SELECT * FROM {$targetMetadata->tableName} WHERE {$targetMetadata->idColumn} = ?";
+        
+        $result = $this->databaseManager->getConnection()->query($query, [$foreignKeyValue]);
+        $targetData = $result->fetch();
+        
+        if (!$targetData) {
+            return null;
+        }
+        
+        $targetEntity = $this->hydrateEntity($targetMetadata, $targetData);
+        $this->identityMap->set($propertyMetadata->relationTargetClass, $foreignKeyValue, $targetEntity);
+        
+        return $targetEntity;
+    }
+
+    /**
+     * Lädt eine hasMany Relation
+     */
+    private function loadHasManyRelation($propertyMetadata, mixed $localKeyValue): array
+    {
+        $relatedData = $this->queryRelatedData(
+            $propertyMetadata->relationTargetClass,
+            $propertyMetadata->relationForeignKey,
+            $localKeyValue
+        );
+
+        return $this->hydrateRelatedEntities(
+            $propertyMetadata->relationTargetClass,
+            $relatedData
+        );
+    }
+
+    /**
+     * Lädt eine one-to-one Relation
+     */
+    private function loadOneToOneRelation($propertyMetadata, mixed $localKeyValue): ?object
+    {
+        $relatedData = $this->queryRelatedData(
+            $propertyMetadata->relationTargetClass,
+            $propertyMetadata->relationForeignKey,
+            $localKeyValue
+        );
+
+        if (empty($relatedData)) {
+            return null;
+        }
+
+        // Für one-to-one nur das erste Ergebnis zurückgeben
+        $entities = $this->hydrateRelatedEntities(
+            $propertyMetadata->relationTargetClass,
+            [$relatedData[0]] // Nur das erste Element
+        );
+
+        return $entities[0] ?? null;
+    }
+
+    /**
+     * Ermittelt die ID einer Entity
+     */
+    private function getEntityId(object $entity, EntityMetadata $metadata): mixed
+    {
+        try {
+            $idProperty = $metadata->reflection->getProperty($metadata->idProperty);
+            return $idProperty->getValue($entity);
+        } catch (\ReflectionException) {
+            // Fallback: versuche über Constructor-Parameter
+            return null;
+        }
+    }
+
+    /**
+     * Lädt verwandte Daten aus der Datenbank
+     */
+    private function queryRelatedData(string $targetClass, string $foreignKey, mixed $localKeyValue): array
+    {
+        $targetMetadata = $this->metadataRegistry->getMetadata($targetClass);
+
+        $query = "SELECT * FROM {$targetMetadata->tableName} WHERE {$foreignKey} = ?";
+        $result = $this->databaseManager->getConnection()->query($query, [$localKeyValue]);
+
+        return $result->fetchAll();
+    }
+
+    /**
+     * Hydratisiert verwandte Entities
+     */
+    private function hydrateRelatedEntities(string $targetClass, array $dataRows): array
+    {
+        $entities = [];
+        $targetMetadata = $this->metadataRegistry->getMetadata($targetClass);
+
+        foreach ($dataRows as $data) {
+            // Prüfe Identity Map
+            $idValue = $data[$targetMetadata->idColumn];
+
+            if ($this->identityMap->has($targetClass, $idValue)) {
+                $entities[] = $this->identityMap->get($targetClass, $idValue);
+            } else {
+                $entity = $this->hydrateEntity($targetMetadata, $data);
+                $this->identityMap->set($targetClass, $idValue, $entity);
+                $entities[] = $entity;
+            }
+        }
+
+        return $entities;
+    }
+
+    /**
+     * Hydratisiert eine einzelne Entity
+     */
+    private function hydrateEntity(EntityMetadata $metadata, array $data): object
+    {
+        $constructor = $metadata->reflection->getConstructor();
+        if (!$constructor) {
+            throw new \RuntimeException("Entity {$metadata->entityClass} must have a constructor");
+        }
+
+        $constructorParams = [];
+        foreach ($constructor->getParameters() as $param) {
+            $paramName = $param->getName();
+            $propertyMetadata = $metadata->getProperty($paramName);
+
+            if (!$propertyMetadata) {
+                throw new \RuntimeException("No metadata found for parameter {$paramName}");
+            }
+
+            $columnName = $propertyMetadata->columnName;
+            $value = $data[$columnName] ?? null;
+
+            // Typ-Konvertierung
+            $convertedValue = $this->typeConverter->convertValue($value, $propertyMetadata);
+            $constructorParams[] = $convertedValue;
+        }
+
+        return new $metadata->entityClass(...$constructorParams);
+    }
+
+    /**
+     * Lädt eine Entity aus der Datenbank
+     */
+    private function loadEntity(EntityMetadata $metadata, mixed $id): object
+    {
+        $query = "SELECT * FROM {$metadata->tableName} WHERE {$metadata->idColumn} = ?";
+        $result = $this->databaseManager->getConnection()->query($query, [$id]);
+        $data = $result->fetch();
+
+        if (!$data) {
+            throw new Exception\EntityNotFoundException($metadata->entityClass, $id);
+        }
+
+        return $this->hydrateEntity($metadata, $data);
+    }
+
+    /**
+     * Initialisiert das Ghost Object (nur für non-readonly Klassen)
+     */
+    private function initializeGhost(object $ghost, EntityMetadata $metadata, mixed $id): void
+    {
+        // Daten aus Datenbank laden
+        $query = "SELECT * FROM {$metadata->tableName} WHERE {$metadata->idColumn} = ?";
+        $result = $this->databaseManager->getConnection()->query($query, [$id]);
+        $data = $result->fetch();
+
+        if (!$data) {
+            throw new Exception\EntityNotFoundException($metadata->entityClass, $id);
+        }
+
+        // Ghost Object Properties setzen
+        foreach ($metadata->properties as $propertyName => $propertyMetadata) {
+            $columnName = $propertyMetadata->columnName;
+            $value = $data[$columnName] ?? null;
+
+            // Typ-Konvertierung
+            $convertedValue = $this->typeConverter->convertValue($value, $propertyMetadata);
+
+            // Property setzen
+            try {
+                $property = $metadata->reflection->getProperty($propertyName);
+                $property->setValue($ghost, $convertedValue);
+            } catch (\ReflectionException) {
+                // Property nicht zugänglich oder existiert nicht
+            }
+        }
+    }
+
+    /**
+     * Prüft ob ein Object ein uninitializiertes Lazy Object ist
+     */
+    public function isLazyGhost(object $object): bool
+    {
+        $reflection = new ReflectionClass($object);
+        return $reflection->isUninitializedLazyObject($object);
+    }
+
+    /**
+     * Forciert die Initialisierung eines Lazy Objects
+     */
+    public function initializeLazyObject(object $object): void
+    {
+        $reflection = new ReflectionClass($object);
+        if ($reflection->isUninitializedLazyObject($object)) {
+            $reflection->initializeLazyObject($object);
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Framework/Database/Metadata/EntityMetadata.php b/src/Framework/Database/Metadata/EntityMetadata.php
new file mode 100644
index 00000000..235af36c
--- /dev/null
+++ b/src/Framework/Database/Metadata/EntityMetadata.php
@@ -0,0 +1,30 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Database\Metadata;
+
+use ReflectionClass;
+
+final readonly class EntityMetadata
+{
+    public function __construct(
+        public string $entityClass,
+        public string $tableName,
+        public string $idColumn,
+        public string $idProperty,
+        public ReflectionClass $reflection,
+        public array $properties
+    ) {}
+
+    public function getProperty(string $name): ?PropertyMetadata
+    {
+        return $this->properties[$name] ?? null;
+    }
+
+    public function getColumnName(string $propertyName): string
+    {
+        $property = $this->getProperty($propertyName);
+        return $property?->columnName ?? $propertyName;
+    }
+}
diff --git a/src/Framework/Database/Metadata/MetadataExtractor.php b/src/Framework/Database/Metadata/MetadataExtractor.php
new file mode 100644
index 00000000..2692c531
--- /dev/null
+++ b/src/Framework/Database/Metadata/MetadataExtractor.php
@@ -0,0 +1,501 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Database\Metadata;
+
+use App\Framework\Database\Attributes\Entity;
+use App\Framework\Database\Attributes\Column;
+use App\Framework\Database\Attributes\Type;
+use App\Framework\Database\Exception\DatabaseException;
+use ReflectionClass;
+use ReflectionProperty;
+use ReflectionParameter;
+use ReflectionNamedType;
+use ReflectionUnionType;
+
+final class MetadataExtractor
+{
+    public function extractMetadata(string $entityClass): EntityMetadata
+    {
+        try {
+            $reflection = new ReflectionClass($entityClass);
+            $entityAttribute = $this->getEntityAttribute($reflection);
+
+            if (!$entityAttribute) {
+                throw new DatabaseException("Class {$entityClass} is not marked as Entity");
+            }
+
+            $tableName = $entityAttribute->tableName ?? $this->getTableNameFromClass($entityClass);
+            $idColumn = $entityAttribute->idColumn ?? 'id';
+
+            $properties = $this->extractProperties($reflection);
+            $relations = $this->extractRelations($reflection);
+            $idProperty = $this->findIdProperty($reflection, $properties, $idColumn);
+
+            return new EntityMetadata(
+                entityClass: $entityClass,
+                tableName: $tableName,
+                idColumn: $idColumn,
+                idProperty: $idProperty,
+                reflection: $reflection,
+                properties: array_merge($properties, $relations)
+            );
+
+        } catch (\ReflectionException $e) {
+            throw new DatabaseException("Failed to analyze entity {$entityClass}: {$e->getMessage()}", 0, $e);
+        }
+    }
+
+    private function extractProperties(ReflectionClass $reflection): array
+    {
+        $properties = [];
+        $constructor = $reflection->getConstructor();
+
+        if (!$constructor) {
+            return $properties;
+        }
+
+        foreach ($constructor->getParameters() as $param) {
+            $propertyMetadata = $this->extractPropertyMetadata($param, $reflection);
+            $properties[$param->getName()] = $propertyMetadata;
+        }
+
+        return $properties;
+    }
+
+    /**
+     * Extrahiert Relation-Properties die nicht im Constructor sind
+     */
+    private function extractRelations(ReflectionClass $reflection): array
+    {
+        $relations = [];
+
+        foreach ($reflection->getProperties() as $property) {
+
+            if ($property->isPromoted()) {
+                continue; // Überspringen, da bereits in extractProperties erfasst
+            }
+
+            $typeAttribute = $this->getTypeAttribute($property);
+
+            if ($typeAttribute) {
+                $relationMetadata = $this->extractRelationMetadata($property, $typeAttribute, $reflection);
+                $relations[$property->getName()] = $relationMetadata;
+                continue;
+            }
+
+            // Prüfe ob der Property-Typ eine Entity-Klasse ist
+            $propertyType = $property->getType();
+            if ($propertyType instanceof \ReflectionNamedType) {
+                $typeName = $propertyType->getName();
+
+                // Prüfe ob die Typ-Klasse eine Entity ist
+                if (class_exists($typeName) && $this->isEntityClass($typeName)) {
+                    $relationMetadata = $this->createRelationMetadataForEntityProperty($property, $typeName, $reflection);
+                    $relations[$property->getName()] = $relationMetadata;
+                    continue;
+                }
+            }
+        }
+
+        return $relations;
+    }
+
+    private function isEntityClass(string $className): bool
+    {
+        try {
+            $classReflection = new \ReflectionClass($className);
+            return $this->getEntityAttribute($classReflection) !== null;
+        } catch (\ReflectionException) {
+            return false;
+        }
+    }
+
+    private function createRelationMetadataForEntityProperty(
+        \ReflectionProperty $property,
+        string $targetClass,
+        \ReflectionClass $parentReflection
+    ): PropertyMetadata {
+        $propertyName = $property->getName();
+
+        $relationType = $this->determineRelationType($property);
+
+        if($relationType === 'belongsTo') {
+            return $this->createBelongsToRelationMetadata($property, $targetClass, $parentReflection);
+        }
+
+        return $this->createHasRelationMetadata($property, $targetClass, $parentReflection, $relationType);
+
+/*
+        // Foreign Key ist der Primary Key der Ziel-Entity
+        $targetReflection = new \ReflectionClass($targetClass);
+        $targetEntityAttribute = $this->getEntityAttribute($targetReflection);
+        $foreignKey = $targetEntityAttribute?->idColumn ?? 'id';
+
+        // Local Key ist die entsprechende Spalte in der aktuellen Entity
+        // Für "image" Property -> "image_id"
+        $localKey = $propertyName . '_id';
+
+
+        // Typ-Analyse der Property
+        $type = $property->getType();
+        $typeInfo = $this->analyzeType($type);
+
+        return new PropertyMetadata(
+            name: $propertyName,
+            columnName: '',
+            type: $typeInfo['mainType'],
+            nullable: $typeInfo['nullable'],
+            hasDefault: true,
+            defaultValue: null,
+            allTypes: $typeInfo['allTypes'],
+            primary: false,
+            autoIncrement: false,
+            isRelation: true,
+            relationTargetClass: $targetClass,
+            relationForeignKey: $foreignKey,
+            relationLocalKey: $localKey,
+            relationType: 'one-to-one'
+        );*/
+    }
+
+    public function determineRelationType(\ReflectionProperty $property): string
+    {
+        $propertyType = $property->getType();
+
+        if($propertyType instanceof \ReflectionNamedType && $propertyType->getName() === 'array') {
+            return 'hasMany';
+        }
+
+        $parentReflection = $property->getDeclaringClass();
+        $possibleForeignKeyProperty = $property->getName() . 'Id';
+        
+        if($this->hasConstructorParameter($parentReflection, $possibleForeignKeyProperty)) {
+            return 'belongsTo';
+        }
+
+        $possibleForeignKeyProperty2 = $property->getName() . '_id';
+        if($this->hasConstructorParameter($parentReflection, $possibleForeignKeyProperty2)) {
+            return 'belongsTo';
+        }
+
+        return 'one-to-one';
+    }
+
+    private function hasConstructorParameter(ReflectionClass $reflection, string $paramName): bool
+    {
+        $constructor = $reflection->getConstructor();
+        if(!$constructor) {
+            return false;
+        }
+
+        foreach($constructor->getParameters() as $param) {
+            if($param->getName() === $paramName) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private function createBelongsToRelationMetadata(\ReflectionProperty $property, string $targetClass, ReflectionClass $parentReflection): PropertyMetadata
+    {
+        $propertyName = $property->getName();
+
+        $foreignKeyProperty = $this->findForeignKeyProperty($propertyName, $parentReflection);
+
+        if(!$foreignKeyProperty) {
+            throw new DatabaseException("Could not find foreign key property for property {$propertyName} in class {$parentReflection->getName()}");
+        }
+
+        $foreignKeyColumnName = $this->getColumnName($foreignKeyProperty, $parentReflection);
+
+        $type = $property->getType();
+        $typeInfo = $this->analyzeType($type);
+
+        return new PropertyMetadata(
+            name: $propertyName,
+            columnName: '',
+            type: $typeInfo['mainType'],
+            nullable: $typeInfo['nullable'],
+            hasDefault: true,
+            defaultValue: null,
+            allTypes: $typeInfo['allTypes'],
+            primary: false,
+            autoIncrement: false,
+            isRelation: true,
+            relationTargetClass: $targetClass,
+            relationForeignKey: $foreignKeyColumnName,  // Jetzt die Spalte, nicht der Parameter-Name
+            relationLocalKey: '', // Wird in belongsTo nicht verwendet
+            relationType: 'belongsTo'
+        );
+    }
+
+    private function findForeignKeyProperty(string $propertyName, ReflectionClass $parentReflection): ?string
+    {
+        $constructor = $parentReflection->getConstructor();
+        if (!$constructor) {
+            return null;
+        }
+
+        // Suche nach {property}Id
+        foreach ($constructor->getParameters() as $param) {
+            if ($param->getName() === $propertyName . 'Id') {
+                return $param->getName();
+            }
+        }
+
+        // Suche nach {property}_id (falls das der Parameter-Name ist)
+        foreach ($constructor->getParameters() as $param) {
+            if ($param->getName() === $propertyName . '_id') {
+                return $param->getName();
+            }
+        }
+
+        return null;
+    }
+
+    private function createHasRelationMetadata(\ReflectionProperty $property, string $targetClass, ReflectionClass $parentReflection, string $relationType): PropertyMetadata
+    {
+        $propertyName = $property->getName();
+
+        $targetReflection = new ReflectionClass($targetClass);
+        $targetEntityAttribute = $this->getEntityAttribute($targetReflection);
+        $foreignKey = $targetEntityAttribute?->idColumn ?? 'id';
+
+        $entityAttribute = $this->getEntityAttribute($parentReflection);
+        $localKey = $entityAttribute?->idColumn ?? 'id';
+
+        $type = $property->getType();
+        $typeInfo = $this->analyzeType($type);
+
+        return new PropertyMetadata(
+            name: $propertyName,
+            columnName: '',
+            type: $typeInfo['mainType'],
+            nullable: $typeInfo['nullable'],
+            hasDefault: true,
+            defaultValue: $relationType === 'hasMany' ? [] : null,
+            allTypes: $typeInfo['allTypes'],
+            primary: false,
+            autoIncrement: false,
+            isRelation: true,
+            relationTargetClass: $targetClass,
+            relationForeignKey: $foreignKey,
+            relationLocalKey: $localKey,
+            relationType: $relationType
+        );
+    }
+
+
+    private function extractRelationMetadata(ReflectionProperty $property, Type $typeAttribute, ReflectionClass $classReflection): PropertyMetadata
+    {
+        $propertyName = $property->getName();
+
+        // Ermittle foreign key automatisch falls nicht gesetzt
+        $foreignKey = $typeAttribute->foreignKey;
+        if (!$foreignKey) {
+            // Konvention: {parent_class}_id
+            $shortName = strtolower($classReflection->getShortName());
+            $foreignKey = $shortName . '_id';
+        }
+
+        // Ermittle local key automatisch falls nicht gesetzt
+        $localKey = $typeAttribute->localKey;
+        if (!$localKey) {
+            // Verwende ID-Property der Entity
+            $entityAttribute = $this->getEntityAttribute($classReflection);
+            $localKey = $entityAttribute?->idColumn ?? 'id';
+        }
+
+        // Typ-Analyse der Property
+        $type = $property->getType();
+        $typeInfo = $this->analyzeType($type);
+
+        return new PropertyMetadata(
+            name: $propertyName,
+            columnName: '', // Relationen haben keine direkte Spalte
+            type: $typeInfo['mainType'],
+            nullable: $typeInfo['nullable'],
+            hasDefault: true, // Relationen haben immer einen Default (leeres Array)
+            defaultValue: [],
+            allTypes: $typeInfo['allTypes'],
+            primary: false,
+            autoIncrement: false,
+            isRelation: true,
+            relationTargetClass: $typeAttribute->targetClass,
+            relationForeignKey: $foreignKey,
+            relationLocalKey: $localKey,
+            relationType: $typeAttribute->type
+        );
+    }
+
+    private function extractPropertyMetadata(ReflectionParameter $param, ReflectionClass $classReflection): PropertyMetadata
+    {
+        $paramName = $param->getName();
+
+        // Column-Name aus Attribute oder Parameter-Name
+        $columnName = $this->getColumnName($paramName, $classReflection);
+
+        // Typ-Analyse
+        $type = $param->getType();
+        $typeInfo = $this->analyzeType($type);
+
+        // Default-Werte und Nullable
+        $hasDefault = $param->isDefaultValueAvailable();
+        $defaultValue = $hasDefault ? $param->getDefaultValue() : null;
+        $nullable = $typeInfo['nullable'] || $hasDefault;
+
+        // Primary Key und Auto-Increment Eigenschaften aus Attribut auslesen
+        $columnAttribute = null;
+        $primary = false;
+        $autoIncrement = false;
+
+        try {
+            $property = $classReflection->getProperty($paramName);
+            $columnAttribute = $this->getColumnAttribute($property);
+            if ($columnAttribute) {
+                $primary = $columnAttribute->primary;
+                $autoIncrement = $columnAttribute->autoIncrement;
+                if ($columnAttribute->nullable) {
+                    $nullable = true;
+                }
+            }
+        } catch (\ReflectionException) {
+            // Property nicht gefunden
+        }
+
+        return new PropertyMetadata(
+            name: $paramName,
+            columnName: $columnName,
+            type: $typeInfo['mainType'],
+            nullable: $nullable,
+            hasDefault: $hasDefault,
+            defaultValue: $defaultValue,
+            allTypes: $typeInfo['allTypes'],
+            primary: $primary,
+            autoIncrement: $autoIncrement
+        );
+    }
+
+    private function getColumnName(string $paramName, ReflectionClass $classReflection): string
+    {
+        try {
+            $property = $classReflection->getProperty($paramName);
+            $columnAttribute = $this->getColumnAttribute($property);
+            return $columnAttribute?->name ?? $paramName;
+        } catch (\ReflectionException) {
+            return $paramName;
+        }
+    }
+
+    private function analyzeType(?\ReflectionType $type): array
+    {
+        if (!$type) {
+            return [
+                'mainType' => 'mixed',
+                'allTypes' => ['mixed'],
+                'nullable' => true
+            ];
+        }
+
+        if ($type instanceof ReflectionNamedType) {
+            return [
+                'mainType' => $type->getName(),
+                'allTypes' => [$type->getName()],
+                'nullable' => $type->allowsNull()
+            ];
+        }
+
+        if ($type instanceof ReflectionUnionType) {
+            $types = [];
+            $nullable = false;
+
+            foreach ($type->getTypes() as $unionType) {
+                if ($unionType instanceof ReflectionNamedType) {
+                    $typeName = $unionType->getName();
+                    if ($typeName === 'null') {
+                        $nullable = true;
+                    } else {
+                        $types[] = $typeName;
+                    }
+                }
+            }
+
+            return [
+                'mainType' => $types[0] ?? 'mixed',
+                'allTypes' => $types,
+                'nullable' => $nullable
+            ];
+        }
+
+        return [
+            'mainType' => 'mixed',
+            'allTypes' => ['mixed'],
+            'nullable' => true
+        ];
+    }
+
+    private function getEntityAttribute(ReflectionClass $reflection): ?Entity
+    {
+        $attributes = $reflection->getAttributes(Entity::class);
+        return $attributes ? $attributes[0]->newInstance() : null;
+    }
+
+    private function getColumnAttribute(ReflectionProperty $property): ?Column
+    {
+        $attributes = $property->getAttributes(Column::class);
+        return $attributes ? $attributes[0]->newInstance() : null;
+    }
+
+    private function getTypeAttribute(ReflectionProperty $property): ?Type
+    {
+        $attributes = $property->getAttributes(Type::class);
+        return $attributes ? $attributes[0]->newInstance() : null;
+    }
+
+    private function getTableNameFromClass(string $className): string
+    {
+        $shortName = new ReflectionClass($className)->getShortName();
+        return strtolower($shortName) . 's';
+    }
+
+    /**
+     * Ermittelt den Property-Namen, der als ID dient
+     */
+    private function findIdProperty(ReflectionClass $reflection, array $properties, string $idColumn): string
+    {
+        // 1. Suche nach Property mit primary=true im Column-Attribut
+        foreach ($properties as $propName => $propMetadata) {
+            try {
+                $property = $reflection->getProperty($propName);
+                $columnAttribute = $this->getColumnAttribute($property);
+
+                if ($columnAttribute && $columnAttribute->primary) {
+                    return $propName;
+                }
+            } catch (\ReflectionException) {
+                // Property nicht gefunden, ignorieren
+            }
+        }
+
+        // 2. Suche nach Property, die dem idColumn entspricht
+        foreach ($properties as $propName => $propMetadata) {
+            if ($propMetadata->columnName === $idColumn) {
+                return $propName;
+            }
+        }
+
+        // 3. Fallback: Property mit Namen 'id'
+        if (isset($properties['id'])) {
+            return 'id';
+        }
+
+        // 4. Wenn nichts passt: Erste Property (nicht ideal, aber besser als nichts)
+        if (!empty($properties)) {
+            return array_key_first($properties);
+        }
+
+        throw new DatabaseException("Keine ID-Property für Entity {$reflection->getName()} gefunden");
+    }
+}
diff --git a/src/Framework/Database/Metadata/MetadataRegistry.php b/src/Framework/Database/Metadata/MetadataRegistry.php
new file mode 100644
index 00000000..16a26a93
--- /dev/null
+++ b/src/Framework/Database/Metadata/MetadataRegistry.php
@@ -0,0 +1,33 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Database\Metadata;
+
+final class MetadataRegistry
+{
+    private array $metadata = [];
+
+    public function __construct(
+        private readonly MetadataExtractor $extractor
+    ) {}
+
+    public function getMetadata(string $entityClass): EntityMetadata
+    {
+        if (!isset($this->metadata[$entityClass])) {
+            $this->metadata[$entityClass] = $this->extractor->extractMetadata($entityClass);
+        }
+
+        return $this->metadata[$entityClass];
+    }
+
+    public function hasMetadata(string $entityClass): bool
+    {
+        return isset($this->metadata[$entityClass]);
+    }
+
+    public function clearCache(): void
+    {
+        $this->metadata = [];
+    }
+}
diff --git a/src/Framework/Database/Metadata/PropertyMetadata.php b/src/Framework/Database/Metadata/PropertyMetadata.php
new file mode 100644
index 00000000..38d55286
--- /dev/null
+++ b/src/Framework/Database/Metadata/PropertyMetadata.php
@@ -0,0 +1,29 @@
+<?php
+
+namespace App\Framework\Database\Metadata;
+
+final readonly class PropertyMetadata
+{
+    public function __construct(
+        public string $name,
+        public string $columnName,
+        public string $type,
+        public bool $nullable,
+        public bool $hasDefault,
+        public mixed $defaultValue,
+        public array $allTypes = [],
+        public bool $primary = false,
+        public bool $autoIncrement = false,
+        // Eigenschaften für Relationen
+        public bool $isRelation = false,
+        public ?string $relationTargetClass = null,
+        public ?string $relationForeignKey = null,
+        public ?string $relationLocalKey = null,
+        public string $relationType = 'hasMany'
+    ) {}
+
+    public function isUnionType(): bool
+    {
+        return count($this->allTypes) > 1;
+    }
+}
diff --git a/src/Framework/Database/Middleware/CacheMiddleware.php b/src/Framework/Database/Middleware/CacheMiddleware.php
new file mode 100644
index 00000000..c1a787a6
--- /dev/null
+++ b/src/Framework/Database/Middleware/CacheMiddleware.php
@@ -0,0 +1,174 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Database\Middleware;
+
+use App\Framework\Database\Cache\CacheStrategy;
+use App\Framework\Database\Cache\QueryCacheKey;
+use App\Framework\Database\Exception\DatabaseException;
+
+final readonly class CacheMiddleware implements QueryMiddleware
+{
+    public function __construct(
+        private CacheStrategy $cacheStrategy,
+        private int $defaultTtlSeconds = 300, // 5 Minuten
+        private bool $enabled = true,
+        private array $cacheableOperations = ['query', 'queryOne', 'queryColumn', 'queryScalar']
+    ) {}
+
+    public function process(QueryContext $context, callable $next): mixed
+    {
+        if (!$this->enabled || !$this->isCacheable($context)) {
+            return $next($context);
+        }
+
+        $cacheKey = $this->generateCacheKey($context);
+
+        // Versuche aus Cache zu lesen
+        $cachedResult = $this->cacheStrategy->get($cacheKey);
+        if ($cachedResult !== null) {
+            // Cache Hit - speichere Statistik
+            $context = $context->withMetadata('cache_hit', true);
+            $context = $context->withMetadata('cache_key', $cacheKey->toString());
+
+            return $this->deserializeResult($cachedResult, $context->operation);
+        }
+
+        // Cache Miss - führe Query aus
+        $result = $next($context);
+
+        // Speichere Ergebnis im Cache
+        $ttl = $this->determineTtl($context);
+        $serializedResult = $this->serializeResult($result, $context->operation);
+
+        $this->cacheStrategy->set($cacheKey, $serializedResult, $ttl);
+
+        // Speichere Cache-Metadaten
+        $context = $context->withMetadata('cache_hit', false);
+        $context = $context->withMetadata('cache_key', $cacheKey->toString());
+        $context = $context->withMetadata('cache_ttl', $ttl);
+
+        return $result;
+    }
+
+    public function getPriority(): int
+    {
+        return 30; // Niedrige Priorität - nach HealthCheck und Retry
+    }
+
+    private function isCacheable(QueryContext $context): bool
+    {
+        // Nur bestimmte Operationen sind cacheable
+        if (!in_array($context->operation, $this->cacheableOperations, true)) {
+            return false;
+        }
+
+        // Transaktions-Queries nicht cachen
+        if ($context->connection->inTransaction()) {
+            return false;
+        }
+
+        // Prüfe auf non-cacheable SQL-Patterns
+        $sql = strtoupper(trim($context->sql));
+
+        // SELECT-Statements sind normalerweise cacheable
+        if (!str_starts_with($sql, 'SELECT')) {
+            return false;
+        }
+
+        // Bestimmte SELECT-Patterns nicht cachen
+        $nonCacheablePatterns = [
+            'NOW()',
+            'CURRENT_TIMESTAMP',
+            'RAND()',
+            'RANDOM()',
+            'UUID()',
+            'CURRENT_USER',
+            'CONNECTION_ID()',
+        ];
+
+        foreach ($nonCacheablePatterns as $pattern) {
+            if (str_contains($sql, $pattern)) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    private function generateCacheKey(QueryContext $context): QueryCacheKey
+    {
+        return new QueryCacheKey(
+            $context->sql,
+            $context->parameters,
+            $context->connection
+        );
+    }
+
+    private function determineTtl(QueryContext $context): int
+    {
+        // Prüfe auf custom TTL in Metadaten
+        if ($context->hasMetadata('cache_ttl')) {
+            return (int) $context->getMetadata('cache_ttl');
+        }
+
+        // Intelligente TTL basierend auf Query-Pattern
+        $sql = strtoupper(trim($context->sql));
+
+        // Lange TTL für statische/referenz Daten
+        if (str_contains($sql, 'INFORMATION_SCHEMA') ||
+            str_contains($sql, 'SHOW TABLES') ||
+            str_contains($sql, 'DESCRIBE ')) {
+            return 3600; // 1 Stunde
+        }
+
+        // Mittlere TTL für Aggregationen
+        if (str_contains($sql, 'COUNT(') ||
+            str_contains($sql, 'SUM(') ||
+            str_contains($sql, 'AVG(') ||
+            str_contains($sql, 'GROUP BY')) {
+            return 900; // 15 Minuten
+        }
+
+        // Standard TTL
+        return $this->defaultTtlSeconds;
+    }
+
+    private function serializeResult(mixed $result, string $operation): array
+    {
+        return [
+            'operation' => $operation,
+            'data' => $result,
+            'timestamp' => time(),
+            'serialized_at' => microtime(true),
+        ];
+    }
+
+    private function deserializeResult(array $cachedData, string $operation): mixed
+    {
+        // Validiere dass Operation übereinstimmt
+        if ($cachedData['operation'] !== $operation) {
+            throw new DatabaseException(
+                "Cache operation mismatch: expected {$operation}, got {$cachedData['operation']}"
+            );
+        }
+
+        return $cachedData['data'];
+    }
+
+    public function invalidatePattern(string $pattern): int
+    {
+        return $this->cacheStrategy->invalidatePattern($pattern);
+    }
+
+    public function invalidateAll(): void
+    {
+        $this->cacheStrategy->clear();
+    }
+
+    public function getCacheStats(): array
+    {
+        return $this->cacheStrategy->getStats();
+    }
+}
diff --git a/src/Framework/Database/Middleware/HealthCheckMiddleware.php b/src/Framework/Database/Middleware/HealthCheckMiddleware.php
new file mode 100644
index 00000000..cf85f0f8
--- /dev/null
+++ b/src/Framework/Database/Middleware/HealthCheckMiddleware.php
@@ -0,0 +1,65 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Database\Middleware;
+
+use App\Framework\Database\Exception\DatabaseException;
+use App\Framework\Database\HealthCheck\ConnectionHealthChecker;
+use App\Framework\Database\HealthCheck\HealthCheckResult;
+
+final readonly class HealthCheckMiddleware implements QueryMiddleware
+{
+    private ConnectionHealthChecker $healthChecker;
+
+    public function __construct(
+        private int $healthCheckInterval = 30, // Sekunden
+        private bool $enabled = true
+    ) {
+        $this->healthChecker = new ConnectionHealthChecker();
+    }
+
+    public function process(QueryContext $context, callable $next): mixed
+    {
+        if (!$this->enabled) {
+            return $next($context);
+        }
+
+        // Prüfe ob Health Check notwendig ist
+        $lastHealthCheck = $context->getMetadata('last_health_check', 0);
+        $currentTime = time();
+
+        if (($currentTime - $lastHealthCheck) >= $this->healthCheckInterval) {
+            $this->performHealthCheck($context);
+            $context = $context->withMetadata('last_health_check', $currentTime);
+        }
+
+        return $next($context);
+    }
+
+    public function getPriority(): int
+    {
+        return 80; // Hohe Priorität - vor Retry aber nach Lazy Loading
+    }
+
+    private function performHealthCheck(QueryContext $context): void
+    {
+        $result = $this->healthChecker->checkHealth($context->connection);
+
+        if (!$result->isHealthy) {
+            throw new DatabaseException(
+                "Health check failed: {$result->message}",
+                0,
+                $result->exception
+            );
+        }
+
+        // Speichere Health Check Ergebnis im Kontext
+        $context->metadata['health_check_result'] = $result;
+    }
+
+    public function getLastHealthCheckResult(QueryContext $context): ?HealthCheckResult
+    {
+        return $context->getMetadata('health_check_result');
+    }
+}
diff --git a/src/Framework/Database/Middleware/MiddlewarePipeline.php b/src/Framework/Database/Middleware/MiddlewarePipeline.php
new file mode 100644
index 00000000..46b2e9c5
--- /dev/null
+++ b/src/Framework/Database/Middleware/MiddlewarePipeline.php
@@ -0,0 +1,67 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Database\Middleware;
+
+final class MiddlewarePipeline
+{
+    /** @var QueryMiddleware[] */
+    private array $middleware = [];
+
+    public function add(QueryMiddleware $middleware): self
+    {
+        $this->middleware[] = $middleware;
+        return $this;
+    }
+
+    public function addMultiple(array $middleware): self
+    {
+        foreach ($middleware as $m) {
+            $this->add($m);
+        }
+        return $this;
+    }
+
+    public function process(QueryContext $context, callable $finalHandler): mixed
+    {
+        // Sortiere Middleware nach Priorität (höchste zuerst)
+        $sortedMiddleware = $this->middleware;
+        usort($sortedMiddleware, fn($a, $b) => $b->getPriority() <=> $a->getPriority());
+
+        // Baue die Pipeline von hinten nach vorne auf
+        $pipeline = $finalHandler;
+
+        for ($i = count($sortedMiddleware) - 1; $i >= 0; $i--) {
+            $middleware = $sortedMiddleware[$i];
+            $pipeline = fn(QueryContext $ctx) => $middleware->process($ctx, $pipeline);
+        }
+
+        return $pipeline($context);
+    }
+
+    public function getMiddleware(): array
+    {
+        return $this->middleware;
+    }
+
+    public function hasMiddleware(string $className): bool
+    {
+        foreach ($this->middleware as $middleware) {
+            if ($middleware instanceof $className) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public function getMiddlewareByType(string $className): ?QueryMiddleware
+    {
+        foreach ($this->middleware as $middleware) {
+            if ($middleware instanceof $className) {
+                return $middleware;
+            }
+        }
+        return null;
+    }
+}
diff --git a/src/Framework/Database/Middleware/QueryContext.php b/src/Framework/Database/Middleware/QueryContext.php
new file mode 100644
index 00000000..4babde22
--- /dev/null
+++ b/src/Framework/Database/Middleware/QueryContext.php
@@ -0,0 +1,35 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Database\Middleware;
+
+use App\Framework\Database\ConnectionInterface;
+
+final class QueryContext
+{
+    public function __construct(
+        public readonly string $operation,
+        public readonly string $sql,
+        public readonly array $parameters,
+        public readonly ConnectionInterface $connection,
+        public array $metadata = []
+    ) {}
+
+    public function withMetadata(string $key, mixed $value): self
+    {
+        $new = clone $this;
+        $new->metadata[$key] = $value;
+        return $new;
+    }
+
+    public function getMetadata(string $key, mixed $default = null): mixed
+    {
+        return $this->metadata[$key] ?? $default;
+    }
+
+    public function hasMetadata(string $key): bool
+    {
+        return array_key_exists($key, $this->metadata);
+    }
+}
diff --git a/src/Framework/Database/Middleware/QueryMiddleware.php b/src/Framework/Database/Middleware/QueryMiddleware.php
new file mode 100644
index 00000000..c9dd2472
--- /dev/null
+++ b/src/Framework/Database/Middleware/QueryMiddleware.php
@@ -0,0 +1,21 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Database\Middleware;
+
+use App\Framework\Database\ConnectionInterface;
+use App\Framework\Database\ResultInterface;
+
+interface QueryMiddleware
+{
+    /**
+     * Verarbeitet eine Query-Operation durch die Middleware
+     */
+    public function process(QueryContext $context, callable $next): mixed;
+
+    /**
+     * Priorität der Middleware (höhere Zahl = früher in der Pipeline)
+     */
+    public function getPriority(): int;
+}
diff --git a/src/Framework/Database/Middleware/RetryMiddleware.php b/src/Framework/Database/Middleware/RetryMiddleware.php
new file mode 100644
index 00000000..746a1d45
--- /dev/null
+++ b/src/Framework/Database/Middleware/RetryMiddleware.php
@@ -0,0 +1,109 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Database\Middleware;
+
+use App\Framework\Database\Exception\DatabaseException;
+use App\Framework\Database\HealthCheck\ConnectionHealthChecker;
+
+final readonly class RetryMiddleware implements QueryMiddleware
+{
+    private ConnectionHealthChecker $healthChecker;
+
+    public function __construct(
+        private int $maxRetries = 3,
+        private int $retryDelayMs = 100,
+        private array $retryableExceptions = [
+            \PDOException::class,
+            DatabaseException::class,
+        ]
+    ) {
+        $this->healthChecker = new ConnectionHealthChecker();
+    }
+
+    public function process(QueryContext $context, callable $next): mixed
+    {
+        // Transaktions-Commits und Rollbacks nicht wiederholen
+        if (in_array($context->operation, ['commit', 'rollback'], true)) {
+            return $next($context);
+        }
+
+        return $this->retryOperation($context, $next);
+    }
+
+    public function getPriority(): int
+    {
+        return 50; // Mittlere Priorität
+    }
+
+    private function retryOperation(QueryContext $context, callable $next): mixed
+    {
+        $attempt = 0;
+        $lastException = null;
+
+        while ($attempt <= $this->maxRetries) {
+            try {
+                return $next($context);
+            } catch (\Throwable $e) {
+                $lastException = $e;
+
+                // Prüfe ob Exception retry-bar ist
+                if (!$this->isRetryableException($e)) {
+                    throw $e;
+                }
+
+                // Prüfe ob wir noch Versuche haben
+                if ($attempt >= $this->maxRetries) {
+                    break;
+                }
+
+                $attempt++;
+
+                // Health Check vor Retry
+                if (!$this->healthChecker->checkConnectionAlive($context->connection)) {
+                    // Für LazyGhost: Connection ist automatisch lazy und wird bei nächstem Zugriff neu initialisiert
+                    // Keine explizite Aktion nötig - LazyGhost handled das automatisch
+                }
+
+                // Exponential Backoff
+                $delay = $this->retryDelayMs * (2 ** ($attempt - 1));
+                usleep($delay * 1000); // usleep benötigt Mikrosekunden
+            }
+        }
+
+        throw new DatabaseException(
+            "Operation failed after {$this->maxRetries} retries. Last error: {$lastException->getMessage()}",
+            0,
+            $lastException
+        );
+    }
+
+    private function isRetryableException(\Throwable $exception): bool
+    {
+        foreach ($this->retryableExceptions as $retryableClass) {
+            if ($exception instanceof $retryableClass) {
+                // Prüfe spezifische Fehlercodes die nicht retry-bar sind
+                if ($exception instanceof \PDOException) {
+                    return $this->isPdoExceptionRetryable($exception);
+                }
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private function isPdoExceptionRetryable(\PDOException $exception): bool
+    {
+        // Bestimmte PDO-Fehler sind nicht retry-bar (z.B. Syntax-Fehler)
+        $nonRetryableCodes = [
+            '42000', // Syntax Error
+            '42S02', // Table doesn't exist
+            '42S22', // Column doesn't exist
+            '23000', // Integrity constraint violation
+        ];
+
+        $sqlState = $exception->getCode();
+        return !in_array($sqlState, $nonRetryableCodes, true);
+    }
+}
diff --git a/src/Framework/Database/MiddlewareConnection.php b/src/Framework/Database/MiddlewareConnection.php
new file mode 100644
index 00000000..6b4b0ae9
--- /dev/null
+++ b/src/Framework/Database/MiddlewareConnection.php
@@ -0,0 +1,113 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Database;
+
+use App\Framework\Database\Middleware\MiddlewarePipeline;
+use App\Framework\Database\Middleware\QueryContext;
+
+final class MiddlewareConnection implements ConnectionInterface
+{
+    public function __construct(
+        private ConnectionInterface $baseConnection,
+        private MiddlewarePipeline $pipeline
+    ) {}
+
+    public function execute(string $sql, array $parameters = []): int
+    {
+        $context = new QueryContext('execute', $sql, $parameters, $this->baseConnection);
+
+        return $this->pipeline->process($context, function(QueryContext $ctx): int {
+            return $ctx->connection->execute($ctx->sql, $ctx->parameters);
+        });
+    }
+
+    public function query(string $sql, array $parameters = []): ResultInterface
+    {
+        $context = new QueryContext('query', $sql, $parameters, $this->baseConnection);
+
+        return $this->pipeline->process($context, function(QueryContext $ctx): ResultInterface {
+            return $ctx->connection->query($ctx->sql, $ctx->parameters);
+        });
+    }
+
+    public function queryOne(string $sql, array $parameters = []): ?array
+    {
+        $context = new QueryContext('queryOne', $sql, $parameters, $this->baseConnection);
+
+        return $this->pipeline->process($context, function(QueryContext $ctx): ?array {
+            return $ctx->connection->queryOne($ctx->sql, $ctx->parameters);
+        });
+    }
+
+    public function queryColumn(string $sql, array $parameters = []): array
+    {
+        $context = new QueryContext('queryColumn', $sql, $parameters, $this->baseConnection);
+
+        return $this->pipeline->process($context, function(QueryContext $ctx): array {
+            return $ctx->connection->queryColumn($ctx->sql, $ctx->parameters);
+        });
+    }
+
+    public function queryScalar(string $sql, array $parameters = []): mixed
+    {
+        $context = new QueryContext('queryScalar', $sql, $parameters, $this->baseConnection);
+
+        return $this->pipeline->process($context, function(QueryContext $ctx): mixed {
+            return $ctx->connection->queryScalar($ctx->sql, $ctx->parameters);
+        });
+    }
+
+    public function beginTransaction(): void
+    {
+        $context = new QueryContext('beginTransaction', '', [], $this->baseConnection);
+
+        $this->pipeline->process($context, function(QueryContext $ctx): void {
+            $ctx->connection->beginTransaction();
+        });
+    }
+
+    public function commit(): void
+    {
+        $context = new QueryContext('commit', '', [], $this->baseConnection);
+
+        $this->pipeline->process($context, function(QueryContext $ctx): void {
+            $ctx->connection->commit();
+        });
+    }
+
+    public function rollback(): void
+    {
+        $context = new QueryContext('rollback', '', [], $this->baseConnection);
+
+        $this->pipeline->process($context, function(QueryContext $ctx): void {
+            $ctx->connection->rollback();
+        });
+    }
+
+    public function inTransaction(): bool
+    {
+        return $this->baseConnection->inTransaction();
+    }
+
+    public function lastInsertId(): string
+    {
+        return $this->baseConnection->lastInsertId();
+    }
+
+    public function getPdo(): \PDO
+    {
+        return $this->baseConnection->getPdo();
+    }
+
+    public function getPipeline(): MiddlewarePipeline
+    {
+        return $this->pipeline;
+    }
+
+    public function getBaseConnection(): ConnectionInterface
+    {
+        return $this->baseConnection;
+    }
+}
diff --git a/src/Framework/Database/Migration/ApplyMigrations.php b/src/Framework/Database/Migration/ApplyMigrations.php
new file mode 100644
index 00000000..1c8dbdbd
--- /dev/null
+++ b/src/Framework/Database/Migration/ApplyMigrations.php
@@ -0,0 +1,32 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Database\Migration;
+
+use App\Framework\Console\ConsoleCommand;
+use App\Framework\Core\PathProvider;
+use App\Framework\Database\DatabaseManager;
+
+final readonly class ApplyMigrations
+{
+    public function __construct(
+        private PathProvider $pathProvider,
+        private DatabaseManager $db
+    ) {}
+
+    #[ConsoleCommand('db:migrate', 'Apply all migrations')]
+    public function __invoke(): void
+    {
+        $path = $this->pathProvider->resolvePath('src/Domain/Media/Migrations');
+
+        $this->db->migrate($path);
+    }
+
+    #[ConsoleCommand('db:rollback', 'Apply a single migration')]
+    public function up(): void
+    {
+        $path = $this->pathProvider->resolvePath('src/Domain/Media/Migrations');
+
+        $this->db->rollback($path);
+    }
+}
diff --git a/src/Framework/Database/Migration/Migration.php b/src/Framework/Database/Migration/Migration.php
new file mode 100644
index 00000000..47b27251
--- /dev/null
+++ b/src/Framework/Database/Migration/Migration.php
@@ -0,0 +1,18 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Database\Migration;
+
+use App\Framework\Database\ConnectionInterface;
+
+interface Migration
+{
+    public function up(ConnectionInterface $connection): void;
+
+    public function down(ConnectionInterface $connection): void;
+
+    public function getVersion(): string;
+
+    public function getDescription(): string;
+}
diff --git a/src/Framework/Database/Migration/MigrationLoader.php b/src/Framework/Database/Migration/MigrationLoader.php
new file mode 100644
index 00000000..5ba45cd3
--- /dev/null
+++ b/src/Framework/Database/Migration/MigrationLoader.php
@@ -0,0 +1,73 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Database\Migration;
+
+use App\Framework\Database\Exception\DatabaseException;
+
+final class MigrationLoader
+{
+    private string $migrationsPath;
+
+    public function __construct(string $migrationsPath)
+    {
+        $this->migrationsPath = $migrationsPath;
+    }
+
+    /**
+     * @return Migration[]
+     */
+    public function loadMigrations(): array
+    {
+        if (!is_dir($this->migrationsPath)) {
+            throw new DatabaseException("Migrations directory does not exist: {$this->migrationsPath}");
+        }
+
+        $migrations = [];
+        $files = glob($this->migrationsPath . '/*.php');
+
+        foreach ($files as $file) {
+            $className = $this->getClassNameFromFile($file);
+
+            if (!$className) {
+                continue;
+            }
+
+            require_once $file;
+
+            if (!class_exists($className)) {
+                continue;
+            }
+
+            $reflection = new \ReflectionClass($className);
+
+            if (!$reflection->implementsInterface(Migration::class)) {
+                continue;
+            }
+
+            $migration = $reflection->newInstance();
+            $migrations[] = $migration;
+        }
+
+        usort($migrations, fn($a, $b) => $a->getVersion() <=> $b->getVersion());
+
+        return $migrations;
+    }
+
+    private function getClassNameFromFile(string $file): ?string
+    {
+        $content = file_get_contents($file);
+
+        $namespace = '';
+        if (preg_match('/namespace\s+([^;]+);/i', $content, $matches)) {
+            $namespace = $matches[1] . '\\';
+        }
+
+        if (preg_match('/class\s+([^\s{]+)/i', $content, $matches)) {
+            return $namespace . $matches[1];
+        }
+
+        return null;
+    }
+}
diff --git a/src/Framework/Database/Migration/MigrationRunner.php b/src/Framework/Database/Migration/MigrationRunner.php
new file mode 100644
index 00000000..7085acfc
--- /dev/null
+++ b/src/Framework/Database/Migration/MigrationRunner.php
@@ -0,0 +1,145 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Database\Migration;
+
+use App\Framework\Database\ConnectionInterface;
+use App\Framework\Database\Exception\DatabaseException;
+use App\Framework\Database\Transaction;
+
+final class MigrationRunner
+{
+    private ConnectionInterface $connection;
+    private string $migrationsTable;
+
+    public function __construct(ConnectionInterface $connection, string $migrationsTable = 'migrations')
+    {
+        $this->connection = $connection;
+        $this->migrationsTable = $migrationsTable;
+        $this->ensureMigrationsTable();
+    }
+
+    /**
+     * @param Migration[] $migrations
+     */
+    public function migrate(array $migrations): array
+    {
+        $executedMigrations = [];
+        $appliedVersions = $this->getAppliedVersions();
+
+        foreach ($migrations as $migration) {
+            if (in_array($migration->getVersion(), $appliedVersions, true)) {
+                continue;
+            }
+
+            try {
+                Transaction::run($this->connection, function() use ($migration) {
+                    echo "Migrating: {$migration->getVersion()} - {$migration->getDescription()}\n";
+
+                    $migration->up($this->connection);
+
+                    $this->connection->execute(
+                        "INSERT INTO {$this->migrationsTable} (version, description, executed_at) VALUES (?, ?, ?)",
+                        [$migration->getVersion(), $migration->getDescription(), date('Y-m-d H:i:s')]
+                    );
+                });
+
+                $executedMigrations[] = $migration->getVersion();
+                echo "Migrated: {$migration->getVersion()}\n";
+            } catch (\Throwable $e) {
+                throw new DatabaseException(
+                    "Migration {$migration->getVersion()} failed: {$e->getMessage()}",
+                    0,
+                    $e
+                );
+            }
+        }
+
+        return $executedMigrations;
+    }
+
+    /**
+     * @param Migration[] $migrations
+     */
+    public function rollback(array $migrations, int $steps = 1): array
+    {
+        $rolledBackMigrations = [];
+        $appliedVersions = $this->getAppliedVersions();
+
+        $sortedMigrations = $migrations;
+        usort($sortedMigrations, fn($a, $b) => $b->getVersion() <=> $a->getVersion());
+
+        $count = 0;
+        foreach ($sortedMigrations as $migration) {
+            if ($count >= $steps) {
+                break;
+            }
+
+            if (!in_array($migration->getVersion(), $appliedVersions, true)) {
+                continue;
+            }
+
+            try {
+                Transaction::run($this->connection, function() use ($migration) {
+                    echo "Rolling back: {$migration->getVersion()} - {$migration->getDescription()}\n";
+
+                    $migration->down($this->connection);
+
+                    $this->connection->execute(
+                        "DELETE FROM {$this->migrationsTable} WHERE version = ?",
+                        [$migration->getVersion()]
+                    );
+                });
+
+                $rolledBackMigrations[] = $migration->getVersion();
+                $count++;
+                echo "Rolled back: {$migration->getVersion()}\n";
+            } catch (\Throwable $e) {
+                throw new DatabaseException(
+                    "Rollback {$migration->getVersion()} failed: {$e->getMessage()}",
+                    0,
+                    $e
+                );
+            }
+        }
+
+        return $rolledBackMigrations;
+    }
+
+    public function getStatus(array $migrations): array
+    {
+        $appliedVersions = $this->getAppliedVersions();
+        $status = [];
+
+        foreach ($migrations as $migration) {
+            $status[] = [
+                'version' => $migration->getVersion(),
+                'description' => $migration->getDescription(),
+                'applied' => in_array($migration->getVersion(), $appliedVersions, true),
+            ];
+        }
+
+        return $status;
+    }
+
+    private function getAppliedVersions(): array
+    {
+        return $this->connection->queryColumn(
+            "SELECT version FROM {$this->migrationsTable} ORDER BY executed_at"
+        );
+    }
+
+    private function ensureMigrationsTable(): void
+    {
+        $sql = "CREATE TABLE IF NOT EXISTS {$this->migrationsTable} (
+            id INT PRIMARY KEY AUTO_INCREMENT,
+            version VARCHAR(255) NOT NULL UNIQUE,
+            description TEXT,
+            executed_at DATETIME NOT NULL,
+            INDEX idx_version (version)
+        )";
+
+        $this->connection->execute($sql);
+    }
+}
diff --git a/src/Framework/Database/PdoConnection.php b/src/Framework/Database/PdoConnection.php
new file mode 100644
index 00000000..551ad3da
--- /dev/null
+++ b/src/Framework/Database/PdoConnection.php
@@ -0,0 +1,104 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Database;
+
+
+use App\Framework\Database\Exception\DatabaseException;
+
+final class PdoConnection implements ConnectionInterface
+{
+    private \PDO $pdo;
+
+    public function __construct(\PDO $pdo)
+    {
+        $this->pdo = $pdo;
+
+        # SOllte bereits aus den Options kommen!
+        #$this->pdo->setAttribute(\PDO::ATTR_ERRMODE, \PDO::ERRMODE_EXCEPTION);
+        #$this->pdo->setAttribute(\PDO::ATTR_DEFAULT_FETCH_MODE, \PDO::FETCH_ASSOC);
+    }
+
+    public function execute(string $sql, array $parameters = []): int
+    {
+        try {
+            $statement = $this->pdo->prepare($sql);
+            $statement->execute($parameters);
+            return $statement->rowCount();
+        } catch (\PDOException $e) {
+            throw new DatabaseException("Failed to execute query: {$e->getMessage()}", 0, $e);
+        }
+    }
+
+    public function query(string $sql, array $parameters = []): ResultInterface
+    {
+        try {
+            $statement = $this->pdo->prepare($sql);
+            $statement->execute($parameters);
+            return new PdoResult($statement);
+        } catch (\PDOException $e) {
+            throw new DatabaseException("Failed to execute query: {$e->getMessage()} --- SQL: {$sql} PARAMETERS: {".implode(", ", $parameters)."}", 0, $e);
+        }
+    }
+
+    public function queryOne(string $sql, array $parameters = []): ?array
+    {
+        $result = $this->query($sql, $parameters);
+        return $result->fetch();
+    }
+
+    public function queryColumn(string $sql, array $parameters = []): array
+    {
+        $result = $this->query($sql, $parameters);
+        return $result->fetchColumn();
+    }
+
+    public function queryScalar(string $sql, array $parameters = []): mixed
+    {
+        $result = $this->query($sql, $parameters);
+        return $result->fetchScalar();
+    }
+
+    public function beginTransaction(): void
+    {
+        try {
+            $this->pdo->beginTransaction();
+        } catch (\PDOException $e) {
+            throw new DatabaseException("Failed to begin transaction: {$e->getMessage()}", 0, $e);
+        }
+    }
+
+    public function commit(): void
+    {
+        try {
+            $this->pdo->commit();
+        } catch (\PDOException $e) {
+            throw new DatabaseException("Failed to commit transaction: {$e->getMessage()}", 0, $e);
+        }
+    }
+
+    public function rollback(): void
+    {
+        try {
+            $this->pdo->rollBack();
+        } catch (\PDOException $e) {
+            throw new DatabaseException("Failed to rollback transaction: {$e->getMessage()}", 0, $e);
+        }
+    }
+
+    public function inTransaction(): bool
+    {
+        return $this->pdo->inTransaction();
+    }
+
+    public function lastInsertId(): string
+    {
+        return $this->pdo->lastInsertId();
+    }
+
+    public function getPdo(): \PDO
+    {
+        return $this->pdo;
+    }
+}
diff --git a/src/Framework/Database/PdoResult.php b/src/Framework/Database/PdoResult.php
new file mode 100644
index 00000000..ee8853c8
--- /dev/null
+++ b/src/Framework/Database/PdoResult.php
@@ -0,0 +1,59 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Database;
+
+use App\Framework\Database\ResultInterface;
+
+final class PdoResult implements ResultInterface
+{
+    private \PDOStatement $statement;
+    private ?array $rows = null;
+
+    public function __construct(\PDOStatement $statement)
+    {
+        $this->statement = $statement;
+    }
+
+    public function fetch(): ?array
+    {
+        $row = $this->statement->fetch();
+        return $row === false ? null : $row;
+    }
+
+    public function fetchAll(): array
+    {
+        if ($this->rows === null) {
+            $this->rows = $this->statement->fetchAll();
+        }
+
+        return $this->rows;
+    }
+
+    public function fetchColumn(int $column = 0): array
+    {
+        return $this->statement->fetchAll(\PDO::FETCH_COLUMN, $column);
+    }
+
+    public function fetchScalar(): mixed
+    {
+        $value = $this->statement->fetchColumn();
+        return $value === false ? null : $value;
+    }
+
+    public function rowCount(): int
+    {
+        return $this->statement->rowCount();
+    }
+
+    public function count(): int
+    {
+        return count($this->fetchAll());
+    }
+
+    public function getIterator(): \ArrayIterator
+    {
+        return new \ArrayIterator($this->fetchAll());
+    }
+}
diff --git a/src/Framework/Database/PooledConnection.php b/src/Framework/Database/PooledConnection.php
new file mode 100644
index 00000000..f5e79473
--- /dev/null
+++ b/src/Framework/Database/PooledConnection.php
@@ -0,0 +1,93 @@
+<?php
+
+namespace App\Framework\Database;
+
+/**
+ * Represents a connection wrapper in a connection pool.
+ *
+ * The PooledConnection class acts as a proxy for an actual database connection, managing the lifecycle
+ * of the underlying connection and facilitating its return to the connection pool upon release or destruction.
+ * It delegates operations to the underlying `ConnectionInterface` implementation.
+ */
+final class PooledConnection implements ConnectionInterface
+{
+    private ConnectionInterface $connection;
+    private ConnectionPool $pool;
+    private string $id;
+    private bool $released = false;
+
+    public function __construct(ConnectionInterface $connection, ConnectionPool $pool, string $id)
+    {
+        $this->connection = $connection;
+        $this->pool = $pool;
+        $this->id = $id;
+    }
+
+    public function execute(string $sql, array $parameters = []): int
+    {
+        return $this->connection->execute($sql, $parameters);
+    }
+
+    public function query(string $sql, array $parameters = []): ResultInterface
+    {
+        return $this->connection->query($sql, $parameters);
+    }
+
+    public function queryOne(string $sql, array $parameters = []): ?array
+    {
+        return $this->connection->queryOne($sql, $parameters);
+    }
+
+    public function queryColumn(string $sql, array $parameters = []): array
+    {
+        return $this->connection->queryColumn($sql, $parameters);
+    }
+
+    public function queryScalar(string $sql, array $parameters = []): mixed
+    {
+        return $this->connection->queryScalar($sql, $parameters);
+    }
+
+    public function beginTransaction(): void
+    {
+        $this->connection->beginTransaction();
+    }
+
+    public function commit(): void
+    {
+        $this->connection->commit();
+    }
+
+    public function rollback(): void
+    {
+        $this->connection->rollback();
+    }
+
+    public function inTransaction(): bool
+    {
+        return $this->connection->inTransaction();
+    }
+
+    public function lastInsertId(): string
+    {
+        return $this->connection->lastInsertId();
+    }
+
+    public function getPdo(): \PDO
+    {
+        return $this->connection->getPdo();
+    }
+
+    public function release(): void
+    {
+        if (!$this->released) {
+            $this->pool->releaseConnection($this->id);
+            $this->released = true;
+        }
+    }
+
+    public function __destruct()
+    {
+        $this->release();
+    }
+}
diff --git a/src/Framework/Database/README.md b/src/Framework/Database/README.md
new file mode 100644
index 00000000..bc53d9ca
--- /dev/null
+++ b/src/Framework/Database/README.md
@@ -0,0 +1,21 @@
+# Database Framework
+
+Ein hochperformantes, erweiterbares Database-Framework für PHP 8.4+ mit Support für Lazy Loading, Middleware-Pipeline, Caching, Health Checks und Retry-Logic.
+
+## Inhaltsverzeichnis
+
+- [Schnellstart](#schnellstart)
+- [Features](#features)
+- [Connection Types](#connection-types)
+- [Middleware System](#middleware-system)
+- [Lazy Loading](#lazy-loading)
+- [Query Caching](#query-caching)
+- [Health Checks](#health-checks)
+- [Retry Logic](#retry-logic)
+- [Konfiguration](#konfiguration)
+- [Best Practices](#best-practices)
+- [Performance](#performance)
+
+## Schnellstart
+
+### Einfache Connection
diff --git a/src/Framework/Database/ReadWriteConnection.php b/src/Framework/Database/ReadWriteConnection.php
new file mode 100644
index 00000000..663e0a6e
--- /dev/null
+++ b/src/Framework/Database/ReadWriteConnection.php
@@ -0,0 +1,136 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Database;
+
+use App\Framework\Database\Exception\DatabaseException;
+
+/**
+ * Class ReadWriteConnection provides a mechanism to handle separate writing and reading database connections.
+ * It ensures that write-heavy operations are directed to a designated write connection,
+ * while read operations are distributed among a pool of read connections.
+ */
+final class ReadWriteConnection implements ConnectionInterface
+{
+    private ConnectionInterface $writeConnection;
+    private array $readConnections;
+    private int $currentReadIndex = 0;
+    private bool $forceWrite = false;
+
+    public function __construct(ConnectionInterface $writeConnection, array $readConnections)
+    {
+        $this->writeConnection = $writeConnection;
+        $this->readConnections = $readConnections;
+
+        if (empty($this->readConnections)) {
+            throw new DatabaseException('At least one read connection is required');
+        }
+    }
+
+    public function execute(string $sql, array $parameters = []): int
+    {
+        $this->forceWrite = true;
+        return $this->writeConnection->execute($sql, $parameters);
+    }
+
+    public function query(string $sql, array $parameters = []): ResultInterface
+    {
+        if ($this->shouldUseWriteConnection($sql)) {
+            return $this->writeConnection->query($sql, $parameters);
+        }
+
+        return $this->getReadConnection()->query($sql, $parameters);
+    }
+
+    public function queryOne(string $sql, array $parameters = []): ?array
+    {
+        if ($this->shouldUseWriteConnection($sql)) {
+            return $this->writeConnection->queryOne($sql, $parameters);
+        }
+
+        return $this->getReadConnection()->queryOne($sql, $parameters);
+    }
+
+    public function queryColumn(string $sql, array $parameters = []): array
+    {
+        if ($this->shouldUseWriteConnection($sql)) {
+            return $this->writeConnection->queryColumn($sql, $parameters);
+        }
+
+        return $this->getReadConnection()->queryColumn($sql, $parameters);
+    }
+
+    public function queryScalar(string $sql, array $parameters = []): mixed
+    {
+        if ($this->shouldUseWriteConnection($sql)) {
+            return $this->writeConnection->queryScalar($sql, $parameters);
+        }
+
+        return $this->getReadConnection()->queryScalar($sql, $parameters);
+    }
+
+    public function beginTransaction(): void
+    {
+        $this->forceWrite = true;
+        $this->writeConnection->beginTransaction();
+    }
+
+    public function commit(): void
+    {
+        $this->writeConnection->commit();
+        $this->forceWrite = false;
+    }
+
+    public function rollback(): void
+    {
+        $this->writeConnection->rollback();
+        $this->forceWrite = false;
+    }
+
+    public function inTransaction(): bool
+    {
+        return $this->writeConnection->inTransaction();
+    }
+
+    public function lastInsertId(): string
+    {
+        return $this->writeConnection->lastInsertId();
+    }
+
+    public function getPdo(): \PDO
+    {
+        return $this->writeConnection->getPdo();
+    }
+
+    public function forceWriteConnection(): void
+    {
+        $this->forceWrite = true;
+    }
+
+    public function resetConnectionMode(): void
+    {
+        $this->forceWrite = false;
+    }
+
+    private function shouldUseWriteConnection(string $sql): bool
+    {
+        if ($this->forceWrite || $this->inTransaction()) {
+            return true;
+        }
+
+        $sql = trim(strtoupper($sql));
+        $writeOperations = ['INSERT', 'UPDATE', 'DELETE', 'CREATE', 'ALTER', 'DROP', 'TRUNCATE'];
+
+        return array_any($writeOperations, fn($operation) => str_starts_with($sql, $operation));
+
+    }
+
+    private function getReadConnection(): ConnectionInterface
+    {
+        $connection = $this->readConnections[$this->currentReadIndex];
+        $this->currentReadIndex = ($this->currentReadIndex + 1) % count($this->readConnections);
+
+        return $connection;
+    }
+}
diff --git a/src/Framework/Database/Repository/EntityRepository.php b/src/Framework/Database/Repository/EntityRepository.php
new file mode 100644
index 00000000..a948528f
--- /dev/null
+++ b/src/Framework/Database/Repository/EntityRepository.php
@@ -0,0 +1,103 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Database\Repository;
+
+use App\Framework\Database\EntityManager;
+
+/**
+ * Basis-Repository für Entities
+ */
+abstract class EntityRepository
+{
+    protected string $entityClass;
+
+    public function __construct(
+        protected EntityManager $entityManager
+    ) {
+        if (!isset($this->entityClass)) {
+            throw new \LogicException(static::class . " must define \$entityClass property");
+        }
+    }
+
+    /**
+     * Findet Entity nach ID
+     */
+    public function find(string $id): ?object
+    {
+        return $this->entityManager->find($this->entityClass, $id);
+    }
+
+    /**
+     * Findet Entity nach ID (eager loading)
+     */
+    public function findEager(string $id): ?object
+    {
+        return $this->entityManager->findEager($this->entityClass, $id);
+    }
+
+    /**
+     * Findet alle Entities
+     */
+    public function findAll(): array
+    {
+        return $this->entityManager->findAll($this->entityClass);
+    }
+
+    /**
+     * Findet alle Entities (eager loading)
+     */
+    public function findAllEager(): array
+    {
+        return $this->entityManager->findAllEager($this->entityClass);
+    }
+
+    /**
+     * Findet Entities nach Kriterien
+     */
+    public function findBy(array $criteria, ?array $orderBy = null, ?int $limit = null): array
+    {
+        return $this->entityManager->findBy($this->entityClass, $criteria, $orderBy, $limit);
+    }
+
+    /**
+     * Findet eine Entity nach Kriterien
+     */
+    public function findOneBy(array $criteria): ?object
+    {
+        return $this->entityManager->findOneBy($this->entityClass, $criteria);
+    }
+
+    /**
+     * Speichert eine Entity
+     */
+    public function save(object $entity): object
+    {
+        return $this->entityManager->save($entity);
+    }
+
+    /**
+     * Speichert mehrere Entities
+     */
+    public function saveAll(array $entities): array
+    {
+        return $this->entityManager->saveAll(...$entities);
+    }
+
+    /**
+     * Löscht eine Entity
+     */
+    public function delete(object $entity): void
+    {
+        $this->entityManager->delete($entity);
+    }
+
+    /**
+     * Führt eine Funktion in einer Transaktion aus
+     */
+    public function transaction(callable $callback): mixed
+    {
+        return $this->entityManager->transaction($callback);
+    }
+}
diff --git a/src/Framework/Database/ResultInterface.php b/src/Framework/Database/ResultInterface.php
new file mode 100644
index 00000000..edccf41f
--- /dev/null
+++ b/src/Framework/Database/ResultInterface.php
@@ -0,0 +1,16 @@
+<?php
+
+namespace App\Framework\Database;
+
+interface ResultInterface extends \IteratorAggregate, \Countable
+{
+    public function fetch(): ?array;
+
+    public function fetchAll(): array;
+
+    public function fetchColumn(int $column = 0): array;
+
+    public function fetchScalar(): mixed;
+
+    public function rowCount(): int;
+}
diff --git a/src/Framework/Database/Transaction.php b/src/Framework/Database/Transaction.php
new file mode 100644
index 00000000..1dab1672
--- /dev/null
+++ b/src/Framework/Database/Transaction.php
@@ -0,0 +1,28 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Database;
+
+final class Transaction
+{
+    public static function run(ConnectionInterface $connection, callable $callback): mixed
+    {
+        // Prüfe ob bereits eine Transaktion läuft
+        if ($connection->inTransaction()) {
+            // Keine neue Transaktion starten, direkt Callback ausführen
+            return $callback();
+        }
+
+        $connection->beginTransaction();
+
+        try {
+            $result = $callback($connection);
+            $connection->commit();
+            return $result;
+        } catch (\Throwable $e) {
+            $connection->rollback();
+            throw $e;
+        }
+    }
+}
diff --git a/src/Framework/Database/TypeCaster/EmailCaster.php b/src/Framework/Database/TypeCaster/EmailCaster.php
new file mode 100644
index 00000000..17d56cff
--- /dev/null
+++ b/src/Framework/Database/TypeCaster/EmailCaster.php
@@ -0,0 +1,41 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Database\TypeCaster;
+
+use App\Domain\ValueObjects\EmailAddress;
+
+final class EmailCaster implements TypeCasterInterface
+{
+    public function fromDatabase(mixed $value, array $options = []): mixed
+    {
+        if ($value === null) {
+            return null;
+        }
+
+        if (is_string($value)) {
+            return new EmailAddress($value);
+        }
+
+        throw new \InvalidArgumentException('Email value must be a string');
+    }
+
+    public function toDatabase(mixed $value, array $options = []): mixed
+    {
+        if ($value === null) {
+            return null;
+        }
+
+        if ($value instanceof EmailAddress) {
+            return $value->value;
+        }
+
+        throw new \InvalidArgumentException('Value must be an EmailAddress instance');
+    }
+
+    public function supports(string $type): bool
+    {
+        return $type === EmailAddress::class;
+    }
+}
diff --git a/src/Framework/Database/TypeCaster/JsonCaster.php b/src/Framework/Database/TypeCaster/JsonCaster.php
new file mode 100644
index 00000000..9dbc8d37
--- /dev/null
+++ b/src/Framework/Database/TypeCaster/JsonCaster.php
@@ -0,0 +1,39 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Database\TypeCaster;
+
+final class JsonCaster implements TypeCasterInterface
+{
+    public function fromDatabase(mixed $value, array $options = []): mixed
+    {
+        if ($value === null) {
+            return null;
+        }
+
+        if (is_string($value)) {
+            $decoded = json_decode($value, true);
+            if (json_last_error() === JSON_ERROR_NONE) {
+                return $decoded;
+            }
+            throw new \InvalidArgumentException('Invalid JSON: ' . json_last_error_msg());
+        }
+
+        return $value;
+    }
+
+    public function toDatabase(mixed $value, array $options = []): mixed
+    {
+        if ($value === null) {
+            return null;
+        }
+
+        return json_encode($value, JSON_THROW_ON_ERROR);
+    }
+
+    public function supports(string $type): bool
+    {
+        return $type === 'array' || $type === 'object';
+    }
+}
diff --git a/src/Framework/Database/TypeCaster/TypeCasterInterface.php b/src/Framework/Database/TypeCaster/TypeCasterInterface.php
new file mode 100644
index 00000000..c9efa75f
--- /dev/null
+++ b/src/Framework/Database/TypeCaster/TypeCasterInterface.php
@@ -0,0 +1,23 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Database\TypeCaster;
+
+interface TypeCasterInterface
+{
+    /**
+     * Konvertiert einen Datenbank-Wert zu einem Value Object
+     */
+    public function fromDatabase(mixed $value, array $options = []): mixed;
+
+    /**
+     * Konvertiert ein Value Object zu einem Datenbank-Wert
+     */
+    public function toDatabase(mixed $value, array $options = []): mixed;
+
+    /**
+     * Prüft ob der Caster für den gegebenen Typ zuständig ist
+     */
+    public function supports(string $type): bool;
+}
diff --git a/src/Framework/Database/TypeCaster/TypeCasterRegistry.php b/src/Framework/Database/TypeCaster/TypeCasterRegistry.php
new file mode 100644
index 00000000..07b5d7c6
--- /dev/null
+++ b/src/Framework/Database/TypeCaster/TypeCasterRegistry.php
@@ -0,0 +1,141 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Database\TypeCaster;
+
+use App\Framework\Database\Exception\DatabaseException;
+
+final class TypeCasterRegistry
+{
+    /** @var array<string, TypeCasterInterface> */
+    private array $casters = [];
+
+    /** @var array<string, TypeCasterInterface> Mapping von Typ zu Caster */
+    private array $typeToCaster = [];
+
+    private bool $discovered = false;
+
+    public function __construct()
+    {
+        $this->discoverCasters();
+    }
+
+    public function register(string $casterClass, TypeCasterInterface $caster): void
+    {
+        $this->casters[$casterClass] = $caster;
+        $this->buildTypeMapping();
+    }
+
+    public function get(string $casterClass): TypeCasterInterface
+    {
+        if (!isset($this->casters[$casterClass])) {
+            // Automatisches Laden wenn Caster noch nicht registriert
+            if (class_exists($casterClass) && is_subclass_of($casterClass, TypeCasterInterface::class)) {
+                $this->casters[$casterClass] = new $casterClass();
+                $this->buildTypeMapping();
+            } else {
+                throw new DatabaseException("Type caster {$casterClass} not found or invalid");
+            }
+        }
+
+        return $this->casters[$casterClass];
+    }
+
+    public function has(string $casterClass): bool
+    {
+        return isset($this->casters[$casterClass]) ||
+               (class_exists($casterClass) && is_subclass_of($casterClass, TypeCasterInterface::class));
+    }
+
+    /**
+     * Findet automatisch den passenden Caster für einen Typ
+     */
+    public function getCasterForType(string $type): ?TypeCasterInterface
+    {
+        if (!$this->discovered) {
+            $this->discoverCasters();
+        }
+
+        return $this->typeToCaster[$type] ?? null;
+    }
+
+    /**
+     * Entdeckt automatisch alle verfügbaren TypeCaster
+     */
+    private function discoverCasters(): void
+    {
+        $casterNamespace = 'App\\Framework\\Database\\TypeCaster\\';
+        $casterPath = __DIR__;
+
+        // Alle PHP-Dateien im TypeCaster-Verzeichnis scannen
+        $files = glob($casterPath . '/*.php');
+
+        foreach ($files as $file) {
+            $className = pathinfo($file, PATHINFO_FILENAME);
+            $fullClassName = $casterNamespace . $className;
+
+            // Nur echte Caster-Klassen laden, nicht das Interface
+            if ($className !== 'TypeCasterInterface' &&
+                class_exists($fullClassName) &&
+                is_subclass_of($fullClassName, TypeCasterInterface::class) &&
+                !new \ReflectionClass($fullClassName)->isAbstract()) {
+
+                try {
+                    $this->casters[$fullClassName] = new $fullClassName();
+                } catch (\Exception $e) {
+                    // Caster konnte nicht instanziiert werden, überspringen
+                }
+            }
+        }
+
+        $this->buildTypeMapping();
+        $this->discovered = true;
+    }
+
+    /**
+     * Baut die Typ-zu-Caster-Zuordnung auf
+     */
+    private function buildTypeMapping(): void
+    {
+        $this->typeToCaster = [];
+
+        foreach ($this->casters as $caster) {
+            // Alle bekannten Typen testen
+            $typesToTest = $this->getAllKnownTypes();
+
+            foreach ($typesToTest as $type) {
+                if ($caster->supports($type)) {
+                    $this->typeToCaster[$type] = $caster;
+                }
+            }
+        }
+    }
+
+    /**
+     * Gibt alle bekannten Typen zurück, die getestet werden sollen
+     */
+    private function getAllKnownTypes(): array
+    {
+        $types = [
+            // Primitive Typen
+            'int', 'float', 'string', 'bool', 'array', 'object',
+            // Häufige Value Objects (dynamisch erweitert)
+        ];
+
+        // Alle existierenden Value Object Klassen hinzufügen
+        $valueObjectsPath = __DIR__ . '/../../../Domain/ValueObjects';
+        if (is_dir($valueObjectsPath)) {
+            $files = glob($valueObjectsPath . '/*.php');
+            foreach ($files as $file) {
+                $className = pathinfo($file, PATHINFO_FILENAME);
+                $fullClassName = 'App\\Domain\\ValueObjects\\' . $className;
+                if (class_exists($fullClassName)) {
+                    $types[] = $fullClassName;
+                }
+            }
+        }
+
+        return $types;
+    }
+}
diff --git a/src/Framework/Database/TypeConverter.php b/src/Framework/Database/TypeConverter.php
new file mode 100644
index 00000000..95ee207c
--- /dev/null
+++ b/src/Framework/Database/TypeConverter.php
@@ -0,0 +1,113 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Database;
+
+use App\Framework\Database\Exception\DatabaseException;
+use App\Framework\Database\Metadata\PropertyMetadata;
+use App\Framework\Database\TypeCaster\TypeCasterRegistry;
+
+final readonly class TypeConverter
+{
+    public function __construct(
+        private ?TypeCasterRegistry $casterRegistry = null
+    ) {}
+
+    public function convertValue(mixed $value, PropertyMetadata $property): mixed
+    {
+        if($property->isRelation) {
+            return $value;
+        }
+
+        // Null-Handling
+        if ($value === null) {
+            if ($property->nullable) {
+                return null;
+            }
+
+            if ($property->hasDefault) {
+                return $property->defaultValue;
+            }
+
+            throw new DatabaseException("Value cannot be null for non-nullable property {$property->name}");
+        }
+
+        // Automatische Type Caster-Erkennung
+        if ($this->casterRegistry) {
+            $caster = $this->casterRegistry->getCasterForType($property->type);
+            if ($caster) {
+                return $caster->fromDatabase($value);
+            }
+        }
+
+        // Union Types: Versuche jeden Typ
+        if ($property->isUnionType()) {
+            foreach ($property->allTypes as $type) {
+                try {
+                    // Zuerst Caster für Union-Typ versuchen
+                    if ($this->casterRegistry) {
+                        $caster = $this->casterRegistry->getCasterForType($type);
+                        if ($caster) {
+                            return $caster->fromDatabase($value);
+                        }
+                    }
+                    // Fallback auf primitive Konvertierung
+                    return $this->convertToType($value, $type);
+                } catch (\Exception) {
+                    continue;
+                }
+            }
+        }
+
+        return $this->convertToType($value, $property->type);
+    }
+
+    /**
+     * Konvertiert Value Objects zurück zu Datenbank-Werten
+     */
+    public function convertToDatabase(mixed $value, PropertyMetadata $property): mixed
+    {
+        if ($value === null) {
+            return null;
+        }
+
+        // Automatische Type Caster-Erkennung basierend auf Objekt-Typ
+        if ($this->casterRegistry && is_object($value)) {
+            $objectType = get_class($value);
+            $caster = $this->casterRegistry->getCasterForType($objectType);
+            if ($caster) {
+                return $caster->toDatabase($value);
+            }
+        }
+
+        // Standard-Konvertierung für primitive Typen
+        return $value;
+    }
+
+    private function convertToType(mixed $value, string $type): mixed
+    {
+        return match($type) {
+            'int' => (int) $value,
+            'float' => (float) $value,
+            'bool' => $this->convertToBool($value),
+            'string' => (string) $value,
+            'array' => is_string($value) ? json_decode($value, true) : (array) $value,
+            default => $value
+        };
+    }
+
+    private function convertToBool(mixed $value): bool
+    {
+        if (is_bool($value)) return $value;
+        if (is_numeric($value)) return (bool) $value;
+        if (is_string($value)) {
+            return match(strtolower(trim($value))) {
+                'true', '1', 'yes', 'on' => true,
+                'false', '0', 'no', 'off', '' => false,
+                default => (bool) $value
+            };
+        }
+        return (bool) $value;
+    }
+}
diff --git a/src/Framework/DateTime/Clock.php b/src/Framework/DateTime/Clock.php
new file mode 100644
index 00000000..fd6c8ced
--- /dev/null
+++ b/src/Framework/DateTime/Clock.php
@@ -0,0 +1,59 @@
+<?php
+
+namespace App\Framework\DateTime;
+
+use App\Framework\DateTime\Exceptions\InvalidDateTimeException;
+use App\Framework\DateTime\Exceptions\InvalidTimezoneException;
+use DateTimeImmutable;
+use Exception;
+
+interface Clock
+{
+    /**
+     * Gibt die aktuelle Zeit zurück.
+     *
+     * @return DateTimeImmutable
+     */
+    public function now(): DateTimeImmutable;
+
+    /**
+     * Erzeugt ein DateTimeImmutable-Objekt aus einem Zeitstempel.
+     *
+     * @param int $timestamp UNIX-Zeitstempel
+     * @return DateTimeImmutable
+     */
+    public function fromTimestamp(int $timestamp): DateTimeImmutable;
+
+    /**
+     * Erzeugt ein DateTimeImmutable-Objekt aus einem String im angegebenen Format.
+     *
+     * @param string $dateTime Der zu parsende Zeitstring
+     * @param string|null $format Optionales Format für die Analyse
+     * @return DateTimeImmutable
+     * @throws InvalidDateTimeException wenn das Parsen fehlschlägt
+     * @throws InvalidTimezoneException wenn eine angegebene Zeitzone ungültig ist
+     */
+    public function fromString(string $dateTime, ?string $format = null): DateTimeImmutable;
+
+    public function today(): DateTimeImmutable;
+
+    public function yesterday(): DateTimeImmutable;
+
+    public function tomorrow(): DateTimeImmutable;
+
+
+    /**
+     * Gibt den aktuellen UNIX-Zeitstempel zurück.
+     *
+     * @return int
+     */
+    public function time(): int;
+
+    /**
+     * Gibt den aktuellen Zeitstempel mit Mikrosekunden zurück.
+     *
+     * @param bool $asFloat Wenn true, wird ein float zurückgegeben, sonst ein Array
+     * @return float|array{float, int}
+     */
+    public function microtime(bool $asFloat = false): float|array;
+}
diff --git a/src/Framework/DateTime/ClockInitializer.php b/src/Framework/DateTime/ClockInitializer.php
new file mode 100644
index 00000000..4c969664
--- /dev/null
+++ b/src/Framework/DateTime/ClockInitializer.php
@@ -0,0 +1,32 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\DateTime;
+
+use App\Framework\Config\AppConfig;
+use App\Framework\DI\Initializer;
+use DateTimeZone;
+
+final readonly class ClockInitializer
+{
+    public function __construct(
+        private AppConfig $config
+    ) {}
+
+    #[Initializer]
+    public function __invoke(): Clock
+    {
+        $timezone = $this->config->timezone;
+
+        $timezone = new DateTimeZone($timezone->value);
+
+        return new SystemClock($timezone);
+    }
+
+    #[Initializer]
+    public function initTimer(): Timer
+    {
+        return new SystemTimer();
+    }
+}
diff --git a/src/Framework/DateTime/DateRange.php b/src/Framework/DateTime/DateRange.php
new file mode 100644
index 00000000..fbcc0bc6
--- /dev/null
+++ b/src/Framework/DateTime/DateRange.php
@@ -0,0 +1,129 @@
+<?php
+
+namespace App\Framework\DateTime;
+
+use App\Framework\DateTime\Exceptions\InvalidDateTimeException;
+use App\Framework\DateTime\Exceptions\InvalidTimezoneException;
+use DateInterval;
+use DateTimeImmutable;
+use DateTimeInterface;
+use DateTimeZone;
+use InvalidArgumentException;
+
+final readonly class DateRange
+{
+    /**
+     * @param DateTimeImmutable $start Startdatum des Bereichs
+     * @param DateTimeImmutable $end Enddatum des Bereichs
+     * @throws InvalidArgumentException wenn das Enddatum vor dem Startdatum liegt
+     */
+    public function __construct(
+        private DateTimeImmutable $start,
+        private DateTimeImmutable $end
+    ) {
+        if ($end < $start) {
+            throw new InvalidArgumentException(
+                'Enddatum kann nicht vor dem Startdatum liegen.'
+            );
+        }
+    }
+
+    /**
+     * Erzeugt einen DateRange aus zwei Datumsstrings.
+     *
+     * @param string $start Startdatum als String
+     * @param string $end Enddatum als String
+     * @param DateTimeZone|string|null $timezone Optionale Zeitzone (Standard: UTC)
+     * @return self
+     * @throws InvalidTimezoneException
+     * @throws InvalidDateTimeException
+     */
+    public static function fromStrings(
+        string $start,
+        string $end,
+        DateTimeZone|string|null $timezone = null
+    ): self {
+        if (is_string($timezone)) {
+            $timezone = DateTime::createTimezone($timezone);
+        }
+
+        $tz = $timezone ?? DateTime::createTimezone('UTC');
+        $startDate = DateTime::fromString($start, $tz);
+        $endDate = DateTime::fromString($end, $tz);
+
+        return new self($startDate, $endDate);
+    }
+
+    /**
+     * Gibt das Startdatum zurück.
+     *
+     * @return DateTimeImmutable
+     */
+    public function getStart(): DateTimeImmutable
+    {
+        return $this->start;
+    }
+
+    /**
+     * Gibt das Enddatum zurück.
+     *
+     * @return DateTimeImmutable
+     */
+    public function getEnd(): DateTimeImmutable
+    {
+        return $this->end;
+    }
+
+    /**
+     * Überprüft, ob ein bestimmtes Datum im Bereich liegt.
+     *
+     * @param DateTimeInterface $date Das zu überprüfende Datum
+     * @return bool
+     */
+    public function contains(DateTimeInterface $date): bool
+    {
+        return ($date >= $this->start && $date <= $this->end);
+    }
+
+    /**
+     * Überprüft, ob ein anderer Bereich vollständig in diesem Bereich enthalten ist.
+     *
+     * @param DateRange $range Der zu überprüfende Bereich
+     * @return bool
+     */
+    public function containsRange(DateRange $range): bool
+    {
+        return ($range->getStart() >= $this->start && $range->getEnd() <= $this->end);
+    }
+
+    /**
+     * Überprüft, ob sich dieser Bereich mit einem anderen überschneidet.
+     *
+     * @param DateRange $range Der zu überprüfende Bereich
+     * @return bool
+     */
+    public function overlaps(DateRange $range): bool
+    {
+        return ($this->start <= $range->getEnd() && $this->end >= $range->getStart());
+    }
+
+    /**
+     * Berechnet die Dauer dieses Bereichs.
+     *
+     * @return DateInterval
+     */
+    public function getDuration(): DateInterval
+    {
+        return $this->start->diff($this->end);
+    }
+
+    /**
+     * Gibt die Dauer in Sekunden zurück.
+     *
+     * @return int
+     */
+    public function getDurationInSeconds(): int
+    {
+        return $this->end->getTimestamp() - $this->start->getTimestamp();
+    }
+}
diff --git a/src/Framework/DateTime/DateTime.php b/src/Framework/DateTime/DateTime.php
new file mode 100644
index 00000000..53cb180a
--- /dev/null
+++ b/src/Framework/DateTime/DateTime.php
@@ -0,0 +1,171 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\DateTime;
+
+use App\Framework\DateTime\Exceptions\InvalidDateTimeException;
+use App\Framework\DateTime\Exceptions\InvalidTimezoneException;
+use DateInterval;
+use DateTimeImmutable;
+use DateTimeInterface;
+use DateTimeZone;
+
+final class DateTime
+{
+    private static ?DateTimeZone $defaultTimezone = null;
+
+    /**
+     * Erstellt ein DateTimeImmutable-Objekt aus einem Zeitstempel.
+     *
+     * @param int $timestamp UNIX-Zeitstempel
+     * @param DateTimeZone|string|null $timezone Optionale Zeitzone (verwendet Standard-Zeitzone wenn null)
+     * @return DateTimeImmutable
+     * @throws InvalidTimezoneException|InvalidDateTimeException wenn die Zeitzone ungültig ist
+     */
+    public static function fromTimestamp(int $timestamp, DateTimeZone|string|null $timezone = null): DateTimeImmutable
+    {
+        $tz = $timezone !== null ? self::createTimezone($timezone) : self::getDefaultTimezone();
+
+        try {
+            return new DateTimeImmutable('@' . $timestamp)->setTimezone($tz);
+        } catch (\Exception $e) {
+            throw new InvalidDateTimeException((string)$timestamp, 'timestamp', $e);
+        }
+    }
+
+    /**
+     * Erstellt ein DateTimeImmutable-Objekt aus einem String.
+     *
+     * @param string $dateTime Der zu parsende Zeitstring
+     * @param DateTimeZone|string|null $timezone Optionale Zeitzone (verwendet Standard-Zeitzone wenn null)
+     * @return DateTimeImmutable
+     * @throws InvalidDateTimeException wenn das Parsen fehlschlägt
+     * @throws InvalidTimezoneException wenn die Zeitzone ungültig ist
+     */
+    public static function fromString(string $dateTime, DateTimeZone|string|null $timezone = null): DateTimeImmutable
+    {
+        $tz = $timezone !== null ? self::createTimezone($timezone) : self::getDefaultTimezone();
+
+        try {
+            return new DateTimeImmutable($dateTime, $tz);
+        } catch (\Exception $e) {
+            throw new InvalidDateTimeException($dateTime, null, $e);
+        }
+    }
+
+    /**
+     * Erstellt ein DateTimeImmutable-Objekt aus einem String mit spezifischem Format.
+     *
+     * @param string $dateTime Der zu parsende Zeitstring
+     * @param string $format Das erwartete Format
+     * @param DateTimeZone|string|null $timezone Optionale Zeitzone (verwendet Standard-Zeitzone wenn null)
+     * @return DateTimeImmutable
+     * @throws InvalidDateTimeException wenn das Parsen fehlschlägt
+     * @throws InvalidTimezoneException wenn die Zeitzone ungültig ist
+     */
+    public static function fromFormat(string $dateTime, string $format, DateTimeZone|string|null $timezone = null): DateTimeImmutable
+    {
+        $tz = $timezone !== null ? self::createTimezone($timezone) : self::getDefaultTimezone();
+
+        try {
+            $date = DateTimeImmutable::createFromFormat($format, $dateTime, $tz);
+
+            if ($date === false) {
+                throw new InvalidDateTimeException($dateTime, $format);
+            }
+
+            return $date;
+        } catch (\Exception $e) {
+            if ($e instanceof InvalidDateTimeException) {
+                throw $e;
+            }
+            throw new InvalidDateTimeException($dateTime, $format, $e);
+        }
+    }
+
+    /**
+     * Erstellt ein DateTimeImmutable-Objekt aus einem anderen DateTimeInterface.
+     *
+     * @param DateTimeInterface $dateTime Das zu konvertierende DateTime
+     * @param DateTimeZone|string|null $timezone Optionale neue Zeitzone
+     * @return DateTimeImmutable
+     * @throws InvalidDateTimeException wenn die Zeitzone ungültig ist
+     */
+    public static function fromDateTime(DateTimeInterface $dateTime, DateTimeZone|string|null $timezone = null): DateTimeImmutable
+    {
+        try {
+            if ($dateTime instanceof DateTimeImmutable) {
+                $result = $dateTime;
+            } else {
+                $result = DateTimeImmutable::createFromInterface($dateTime);
+            }
+
+            if ($timezone !== null) {
+                $tz = self::createTimezone($timezone);
+                $result = $result->setTimezone($tz);
+            }
+
+            return $result;
+        } catch (\Exception $e) {
+            throw new InvalidDateTimeException($dateTime->format('c'), null, $e);
+        }
+    }
+
+    /**
+     * Erstellt ein DateInterval-Objekt.
+     *
+     * @param string $interval Das Interval im ISO 8601 Format (z.B. 'P1D', 'PT1H')
+     * @return DateInterval
+     * @throws InvalidDateTimeException wenn das Interval ungültig ist
+     */
+    public static function createInterval(string $interval): DateInterval
+    {
+        try {
+            return new DateInterval($interval);
+        } catch (\Exception $e) {
+            throw new InvalidDateTimeException($interval, 'DateInterval', $e);
+        }
+    }
+
+    /**
+     * Erstellt eine DateTimeZone.
+     *
+     * @param DateTimeZone|string $timezone Die Zeitzone
+     * @return DateTimeZone
+     * @throws InvalidTimezoneException wenn die Zeitzone ungültig ist
+     */
+    public static function createTimezone(DateTimeZone|string $timezone): DateTimeZone
+    {
+        if ($timezone instanceof DateTimeZone) {
+            return $timezone;
+        }
+
+        try {
+            return new DateTimeZone($timezone);
+        } catch (\Exception $e) {
+            throw new InvalidTimezoneException($timezone, $e);
+        }
+    }
+
+    /**
+     * Gibt die Standard-Zeitzone zurück.
+     *
+     * @return DateTimeZone
+     */
+    public static function getDefaultTimezone(): DateTimeZone
+    {
+        return self::$defaultTimezone ?? new DateTimeZone('Europa/Berlin');
+    }
+
+    /**
+     * Setzt eine neue Standard-Zeitzone.
+     *
+     * @param DateTimeZone|string $timezone Die neue Standard-Zeitzone
+     * @throws InvalidTimezoneException wenn die Zeitzone ungültig ist
+     */
+    public static function setDefaultTimezone(DateTimeZone|string $timezone): void
+    {
+        self::$defaultTimezone = self::createTimezone($timezone);
+    }
+}
diff --git a/src/Framework/DateTime/DateTimeFormatter.php b/src/Framework/DateTime/DateTimeFormatter.php
new file mode 100644
index 00000000..0825defe
--- /dev/null
+++ b/src/Framework/DateTime/DateTimeFormatter.php
@@ -0,0 +1,133 @@
+<?php
+
+namespace App\Framework\DateTime;
+
+use DateInvalidTimeZoneException;
+use DateMalformedStringException;
+use DateTimeImmutable;
+use DateTimeInterface;
+use DateTimeZone;
+
+class DateTimeFormatter
+{
+    /**
+     * Standard-Zeitzone für Formatierungen
+     */
+    private DateTimeZone $timezone;
+
+    /**
+     * @param DateTimeZone|string|null $timezone Die zu verwendende Zeitzone (Standard: UTC)
+     * @throws DateInvalidTimeZoneException
+     */
+    public function __construct(DateTimeZone|string|null $timezone = null)
+    {
+        if (is_string($timezone)) {
+            $timezone = new DateTimeZone($timezone);
+        }
+
+        $this->timezone = $timezone ?? new DateTimeZone('Europe/Berlin');
+    }
+
+    /**
+     * Formatiert ein DateTime im ISO8601-Format.
+     *
+     * @param DateTimeInterface $dateTime Das zu formatierende DateTime
+     * @return string
+     * @throws DateMalformedStringException
+     */
+    public function formatIso8601(DateTimeInterface $dateTime): string
+    {
+        return $this->format($dateTime, DateTimeInterface::ATOM);
+    }
+
+    /**
+     * Formatiert ein DateTime im SQL-Datetime-Format.
+     *
+     * @param DateTimeInterface $dateTime Das zu formatierende DateTime
+     * @return string
+     * @throws DateMalformedStringException
+     */
+    public function formatSql(DateTimeInterface $dateTime): string
+    {
+        return $this->format($dateTime, 'Y-m-d H:i:s');
+    }
+
+    /**
+     * Formatiert ein DateTime nur als Datum.
+     *
+     * @param DateTimeInterface $dateTime Das zu formatierende DateTime
+     * @return string
+     * @throws DateMalformedStringException
+     */
+    public function formatDate(DateTimeInterface $dateTime): string
+    {
+        #return $this->format($dateTime, 'Y-m-d');
+
+        return $this->format($dateTime, 'd.m.Y');
+    }
+
+    /**
+     * Formatiert ein DateTime nur als Zeit.
+     *
+     * @param DateTimeInterface $dateTime Das zu formatierende DateTime
+     * @return string
+     * @throws DateMalformedStringException
+     */
+    public function formatTime(DateTimeInterface $dateTime): string
+    {
+        return $this->format($dateTime, 'H:i:s');
+    }
+
+    /**
+     * Formatiert ein DateTime in einem benutzerdefinierten Format.
+     *
+     * @param DateTimeInterface $dateTime Das zu formatierende DateTime
+     * @param string $format Das Format-Pattern
+     * @return string
+     * @throws DateMalformedStringException
+     */
+    public function format(DateTimeInterface $dateTime, string $format): string
+    {
+        // Stelle sicher, dass die Zeitzone korrekt ist
+        $dateInCorrectTimezone = $this->ensureTimezone($dateTime);
+
+        return $dateInCorrectTimezone->format($format);
+    }
+
+    /**
+     * Stellt sicher, dass ein DateTime die korrekte Zeitzone hat.
+     *
+     * @param DateTimeInterface $dateTime Das zu überprüfende DateTime
+     * @return DateTimeImmutable
+     * @throws DateMalformedStringException
+     */
+    private function ensureTimezone(DateTimeInterface $dateTime): DateTimeImmutable
+    {
+        if ($dateTime->getTimezone()->getName() !== $this->timezone->getName()) {
+            if ($dateTime instanceof DateTimeImmutable) {
+                return $dateTime->setTimezone($this->timezone);
+            }
+
+            // Konvertiere DateTime zu DateTimeImmutable mit der richtigen Zeitzone
+            return new DateTimeImmutable('@' . $dateTime->getTimestamp())
+                ->setTimezone($this->timezone);
+        }
+
+        if ($dateTime instanceof DateTimeImmutable) {
+            return $dateTime;
+        }
+
+        // Konvertiere DateTime zu DateTimeImmutable
+        return DateTimeImmutable::createFromInterface($dateTime);
+    }
+
+    /**
+     * Gibt die verwendete Zeitzone zurück.
+     *
+     * @return DateTimeZone
+     */
+    public function getTimezone(): DateTimeZone
+    {
+        return $this->timezone;
+    }
+}
diff --git a/src/Framework/DateTime/Exceptions/InvalidDateTimeException.php b/src/Framework/DateTime/Exceptions/InvalidDateTimeException.php
new file mode 100644
index 00000000..389c6bc9
--- /dev/null
+++ b/src/Framework/DateTime/Exceptions/InvalidDateTimeException.php
@@ -0,0 +1,19 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\DateTime\Exceptions;
+
+use Exception;
+
+class InvalidDateTimeException extends Exception
+{
+    public function __construct(string $dateTime, ?string $format = null, ?\Throwable $previous = null)
+    {
+        $message = $format !== null
+            ? sprintf('Konnte DateTime nicht aus "%s" mit Format "%s" erstellen', $dateTime, $format)
+            : sprintf('Ungültiges DateTime-Format: "%s"', $dateTime);
+
+        parent::__construct($message, 0, $previous);
+    }
+}
diff --git a/src/Framework/DateTime/Exceptions/InvalidTimezoneException.php b/src/Framework/DateTime/Exceptions/InvalidTimezoneException.php
new file mode 100644
index 00000000..43c38fb0
--- /dev/null
+++ b/src/Framework/DateTime/Exceptions/InvalidTimezoneException.php
@@ -0,0 +1,19 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\DateTime\Exceptions;
+
+use Exception;
+
+class InvalidTimezoneException extends Exception
+{
+    public function __construct(string $timezone, ?\Throwable $previous = null)
+    {
+        parent::__construct(
+            sprintf('Ungültige Zeitzone: "%s"', $timezone),
+            0,
+            $previous
+        );
+    }
+}
diff --git a/src/Framework/DateTime/FrozenClock.php b/src/Framework/DateTime/FrozenClock.php
new file mode 100644
index 00000000..8f6f9256
--- /dev/null
+++ b/src/Framework/DateTime/FrozenClock.php
@@ -0,0 +1,162 @@
+<?php
+
+namespace App\Framework\DateTime;
+
+use App\Framework\DateTime\Exceptions\InvalidDateTimeException;
+use App\Framework\DateTime\Exceptions\InvalidTimezoneException;
+use DateInvalidOperationException;
+use DateTimeImmutable;
+use DateTimeZone;
+
+final class FrozenClock implements Clock
+{
+    private DateTimeImmutable $frozenTime;
+    private DateTimeZone $timezone;
+
+    /**
+     * @param DateTimeImmutable|string|null $time Die fixierte Zeit (Standard: aktuelle Zeit über SystemClock)
+     * @param DateTimeZone|string|null $timezone Die zu verwendende Zeitzone (Standard: UTC)
+     * @throws InvalidDateTimeException wenn die Zeit ungültig ist
+     * @throws InvalidTimezoneException wenn die Zeitzone ungültig ist
+     */
+    public function __construct(
+        DateTimeImmutable|string|null $time = null,
+        DateTimeZone|string|null $timezone = null
+    ) {
+        $this->timezone = $timezone !== null
+            ? DateTime::createTimezone($timezone)
+            : DateTime::getDefaultTimezone();
+
+        if ($time === null) {
+            // Verwende SystemClock für die initiale Zeit
+            $systemClock = new SystemClock($this->timezone);
+            $this->frozenTime = $systemClock->now();
+        } elseif (is_string($time)) {
+            $this->frozenTime = DateTime::fromString($time, $this->timezone);
+        } else {
+            $this->frozenTime = DateTime::fromDateTime($time, $this->timezone);
+        }
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function now(): DateTimeImmutable
+    {
+        return $this->frozenTime;
+    }
+
+    /**
+     * {@inheritDoc}
+     * @throws InvalidTimezoneException
+     */
+    public function fromTimestamp(int $timestamp): DateTimeImmutable
+    {
+        return DateTime::fromTimestamp($timestamp, $this->timezone);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function fromString(string $dateTime, ?string $format = null): DateTimeImmutable
+    {
+        if ($format === null) {
+            return DateTime::fromString($dateTime, $this->timezone);
+        }
+
+        return DateTime::fromFormat($dateTime, $format, $this->timezone);
+    }
+
+    /**
+     * Erstellt ein Today-Datum (00:00:00) basierend auf der gefrorenen Zeit.
+     *
+     * @return DateTimeImmutable
+     */
+    public function today(): DateTimeImmutable
+    {
+        return $this->frozenTime->setTime(0, 0, 0);
+    }
+
+    /**
+     * Erstellt ein Tomorrow-Datum (00:00:00) basierend auf der gefrorenen Zeit.
+     *
+     * @return DateTimeImmutable
+     */
+    public function tomorrow(): DateTimeImmutable
+    {
+        return $this->frozenTime->modify('+1 day')->setTime(0, 0, 0);
+    }
+
+    /**
+     * Erstellt ein Yesterday-Datum (00:00:00) basierend auf der gefrorenen Zeit.
+     *
+     * @return DateTimeImmutable
+     */
+    public function yesterday(): DateTimeImmutable
+    {
+        return $this->frozenTime->modify('-1 day')->setTime(0, 0, 0);
+    }
+
+    /**
+     * Setzt die fixierte Zeit auf einen neuen Wert.
+     *
+     * @param DateTimeImmutable|string $time Die neue fixierte Zeit
+     * @return self
+     * @throws InvalidDateTimeException|InvalidTimezoneException wenn die Zeit ungültig ist
+     */
+    public function setTo(DateTimeImmutable|string $time): self
+    {
+        if (is_string($time)) {
+            $this->frozenTime = DateTime::fromString($time, $this->timezone);
+        } else {
+            $this->frozenTime = DateTime::fromDateTime($time, $this->timezone);
+        }
+
+        return $this;
+    }
+
+    /**
+     * Bewegt die fixierte Zeit um eine bestimmte Zeit vorwärts.
+     *
+     * @param string $interval Eine DateInterval-kompatible Zeichenfolge (z.B. 'PT1H' für eine Stunde)
+     * @return self
+     * @throws InvalidDateTimeException wenn das Interval ungültig ist
+     */
+    public function moveForward(string $interval): self
+    {
+        $dateInterval = DateTime::createInterval($interval);
+        $this->frozenTime = $this->frozenTime->add($dateInterval);
+        return $this;
+    }
+
+    /**
+     * Bewegt die fixierte Zeit um eine bestimmte Zeit zurück.
+     *
+     * @param string $interval Eine DateInterval-kompatible Zeichenfolge (z.B. 'PT1H' für eine Stunde)
+     * @return self
+     * @throws InvalidDateTimeException|DateInvalidOperationException wenn das Interval ungültig ist
+     */
+    public function moveBackward(string $interval): self
+    {
+        $dateInterval = DateTime::createInterval($interval);
+        $this->frozenTime = $this->frozenTime->sub($dateInterval);
+        return $this;
+    }
+
+    public function time(): int
+    {
+        return $this->now()->getTimestamp();
+    }
+
+    public function microtime(bool $asFloat = false): float|array
+    {
+        $timestamp = $this->now()->getTimestamp();
+        $microseconds = 0; // In FrozenClock haben wir keine Mikrosekunden-Präzision
+
+        if ($asFloat) {
+            return (float)$timestamp;
+        }
+
+        return [(float)$timestamp, $microseconds];
+    }
+}
diff --git a/src/Framework/DateTime/SystemClock.php b/src/Framework/DateTime/SystemClock.php
new file mode 100644
index 00000000..a498e23f
--- /dev/null
+++ b/src/Framework/DateTime/SystemClock.php
@@ -0,0 +1,100 @@
+<?php
+
+namespace App\Framework\DateTime;
+
+use App\Framework\DateTime\Exceptions\InvalidDateTimeException;
+use App\Framework\DateTime\Exceptions\InvalidTimezoneException;
+use DateTimeImmutable;
+use DateTimeZone;
+use function microtime;
+use function time;
+
+final readonly class SystemClock implements Clock
+{
+    private DateTimeZone $timezone;
+
+    /**
+     * @param DateTimeZone|string|null $timezone Die zu verwendende Zeitzone (Standard: UTC)
+     * @throws InvalidTimezoneException wenn die Zeitzone ungültig ist
+     */
+    public function __construct(DateTimeZone|string|null $timezone = null)
+    {
+        $this->timezone = $timezone !== null
+            ? DateTime::createTimezone($timezone)
+            : DateTime::getDefaultTimezone();
+    }
+
+    /**
+     * {@inheritDoc}
+     * @throws InvalidDateTimeException
+     */
+    public function now(): DateTimeImmutable
+    {
+        try {
+            return new DateTimeImmutable('now', $this->timezone);
+        } catch (\Exception $e) {
+            throw new InvalidDateTimeException('now', null, $e);
+        }
+    }
+
+    /**
+     * {@inheritDoc}
+     * @throws InvalidTimezoneException|InvalidDateTimeException
+     */
+    public function fromTimestamp(int $timestamp): DateTimeImmutable
+    {
+        return DateTime::fromTimestamp($timestamp, $this->timezone);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function fromString(string $dateTime, ?string $format = null): DateTimeImmutable
+    {
+        if ($format === null) {
+            return DateTime::fromString($dateTime, $this->timezone);
+        }
+
+        return DateTime::fromFormat($dateTime, $format, $this->timezone);
+    }
+
+    /**
+     * Erstellt ein Today-Datum (00:00:00).
+     *
+     * @return DateTimeImmutable
+     */
+    public function today(): DateTimeImmutable
+    {
+        return DateTime::fromString('today', $this->timezone);
+    }
+
+    /**
+     * Erstellt ein Tomorrow-Datum (00:00:00).
+     *
+     * @return DateTimeImmutable
+     */
+    public function tomorrow(): DateTimeImmutable
+    {
+        return DateTime::fromString('tomorrow', $this->timezone);
+    }
+
+    /**
+     * Erstellt ein Yesterday-Datum (00:00:00).
+     *
+     * @return DateTimeImmutable
+     */
+    public function yesterday(): DateTimeImmutable
+    {
+        return DateTime::fromString('yesterday', $this->timezone);
+    }
+
+    public function time(): int
+    {
+        return time();
+    }
+
+    public function microtime(bool $asFloat = false): float|array
+    {
+        return microtime($asFloat);
+    }
+}
diff --git a/src/Framework/DateTime/SystemTimer.php b/src/Framework/DateTime/SystemTimer.php
new file mode 100644
index 00000000..b22bdd77
--- /dev/null
+++ b/src/Framework/DateTime/SystemTimer.php
@@ -0,0 +1,26 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\DateTime;
+
+use function sleep;
+use function usleep;
+
+final readonly class SystemTimer implements Timer
+{
+
+    public function sleep(int $seconds): void
+    {
+        sleep($seconds);
+    }
+
+    public function usleep(int $microseconds): void
+    {
+        usleep($microseconds);
+    }
+
+    public function msleep(int $milliseconds): void
+    {
+        usleep($milliseconds * 1000);
+    }
+}
diff --git a/src/Framework/DateTime/Timer.php b/src/Framework/DateTime/Timer.php
new file mode 100644
index 00000000..c1b7e2c5
--- /dev/null
+++ b/src/Framework/DateTime/Timer.php
@@ -0,0 +1,28 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\DateTime;
+
+interface Timer
+{
+    /**
+     * Pausiert die Ausführung für die angegebene Anzahl von Sekunden.
+     *
+     * @param int $seconds Anzahl der Sekunden
+     */
+    public function sleep(int $seconds): void;
+
+    /**
+     * Pausiert die Ausführung für die angegebene Anzahl von Mikrosekunden.
+     *
+     * @param int $microseconds Anzahl der Mikrosekunden
+     */
+    public function usleep(int $microseconds): void;
+
+    /**
+     * Pausiert die Ausführung für die angegebene Anzahl von Millisekunden.
+     *
+     * @param int $milliseconds Anzahl der Millisekunden
+     */
+    public function msleep(int $milliseconds): void;
+}
diff --git a/src/Framework/DateTime/Timezone.php b/src/Framework/DateTime/Timezone.php
new file mode 100644
index 00000000..dbd62f8f
--- /dev/null
+++ b/src/Framework/DateTime/Timezone.php
@@ -0,0 +1,9 @@
+<?php
+
+namespace App\Framework\DateTime;
+
+enum Timezone: string
+{
+    case UTC = 'UTC';
+    case EuropeBerlin = 'Europe/Berlin';
+}
diff --git a/src/Framework/Debug/DebugEntry.php b/src/Framework/Debug/DebugEntry.php
new file mode 100644
index 00000000..19043641
--- /dev/null
+++ b/src/Framework/Debug/DebugEntry.php
@@ -0,0 +1,147 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Debug;
+
+/**
+ * Repräsentiert einen einzelnen Debug-Eintrag mit allen relevanten Informationen.
+ */
+final class DebugEntry
+{
+    /** @var \DateTimeImmutable */
+    private \DateTimeImmutable $timestamp;
+
+    /** @var string */
+    private string $memory;
+
+    /** @var string */
+    private string $peakMemory;
+
+    /**
+     * Erstellt einen neuen Debug-Eintrag
+     */
+    public function __construct(
+        private readonly mixed  $data,
+        private readonly string $label,
+        private readonly string $file,
+        private readonly int    $line,
+        private readonly EntryType $type = EntryType::STANDARD
+    ) {
+        $this->timestamp = new \DateTimeImmutable(timezone: new \DateTimeZone('Europe/Berlin'));
+        $this->memory = self::formatBytes(memory_get_usage(true));
+        $this->peakMemory = self::formatBytes(memory_get_peak_usage(true));
+    }
+
+    /**
+     * Gibt die Debug-Daten zurück
+     */
+    public function getData(): mixed
+    {
+        return $this->data;
+    }
+
+    /**
+     * Gibt das Label zurück
+     */
+    public function getLabel(): string
+    {
+        return $this->label;
+    }
+
+    /**
+     * Gibt den Pfad der Datei zurück
+     */
+    public function getFile(): string
+    {
+        return $this->file;
+    }
+
+    /**
+     * Gibt die Zeilennummer zurück
+     */
+    public function getLine(): int
+    {
+        return $this->line;
+    }
+
+    /**
+     * Gibt den Dateinamen ohne Pfad zurück
+     */
+    public function getFilename(): string
+    {
+        return basename($this->file);
+    }
+
+    /**
+     * Gibt den Zeitstempel zurück
+     */
+    public function getTimestamp(): \DateTimeImmutable
+    {
+        return $this->timestamp;
+    }
+
+    /**
+     * Gibt den formatierten Zeitstempel zurück
+     */
+    public function getFormattedTimestamp(string $format = 'Y-m-d H:i:s'): string
+    {
+        return $this->timestamp->format($format);
+    }
+
+    /**
+     * Gibt den aktuellen Speicherverbrauch zurück
+     */
+    public function getMemory(): string
+    {
+        return $this->memory;
+    }
+
+    /**
+     * Gibt den höchsten Speicherverbrauch zurück
+     */
+    public function getPeakMemory(): string
+    {
+        return $this->peakMemory;
+    }
+
+    /**
+     * Gibt den Typ des Eintrags zurück
+     */
+    public function getType(): EntryType
+    {
+        return $this->type;
+    }
+
+    /**
+     * Erstellt ein Array mit allen Debug-Daten
+     */
+    public function toArray(): array
+    {
+        return [
+            'data' => $this->data,
+            'label' => $this->label,
+            'file' => $this->file,
+            'line' => $this->line,
+            'timestamp' => $this->getFormattedTimestamp(),
+            'memory' => $this->memory,
+            'peak_memory' => $this->peakMemory,
+            'type' => $this->type->name,
+        ];
+    }
+
+    /**
+     * Formatiert Bytes in lesbare Größen
+     */
+    private static function formatBytes(int $bytes): string
+    {
+        $units = ['B', 'KB', 'MB', 'GB'];
+        $bytes = max($bytes, 0);
+        $pow = floor(($bytes ? log($bytes) : 0) / log(1024));
+        $pow = min($pow, count($units) - 1);
+
+        $bytes /= (1 << (10 * $pow));
+
+        return round($bytes, 2) . ' ' . $units[$pow];
+    }
+}
diff --git a/src/Framework/Debug/DebugRegistry.php b/src/Framework/Debug/DebugRegistry.php
new file mode 100644
index 00000000..1a57a497
--- /dev/null
+++ b/src/Framework/Debug/DebugRegistry.php
@@ -0,0 +1,69 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Debug;
+
+/**
+ * Registry-Klasse zum Speichern aller Debug-Einträge.
+ */
+final class DebugRegistry
+{
+    /** @var DebugEntry[] */
+    private array $entries = [];
+
+    /** @var int */
+    private int $maxEntries = 100;
+
+    /**
+     * Fügt einen Debug-Eintrag hinzu
+     */
+    public function addEntry(DebugEntry $entry): void
+    {
+        // Bei Überschreitung der maximalen Anzahl, ältesten Eintrag entfernen
+        if (count($this->entries) >= $this->maxEntries) {
+            array_shift($this->entries);
+        }
+
+        $this->entries[] = $entry;
+    }
+
+    /**
+     * Gibt alle gespeicherten Debug-Einträge zurück
+     *
+     * @return DebugEntry[]
+     */
+    public function getEntries(): array
+    {
+        return $this->entries;
+    }
+
+    /**
+     * Gibt die Anzahl der gespeicherten Einträge zurück
+     */
+    public function getCount(): int
+    {
+        return count($this->entries);
+    }
+
+    /**
+     * Löscht alle gespeicherten Einträge
+     */
+    public function clear(): void
+    {
+        $this->entries = [];
+    }
+
+    /**
+     * Setzt die maximale Anzahl an Einträgen
+     */
+    public function setMaxEntries(int $maxEntries): void
+    {
+        $this->maxEntries = max(1, $maxEntries);
+
+        // Überschüssige Einträge entfernen
+        if (count($this->entries) > $this->maxEntries) {
+            $this->entries = array_slice($this->entries, -$this->maxEntries);
+        }
+    }
+}
diff --git a/src/Framework/Debug/DebugServiceProvider.php b/src/Framework/Debug/DebugServiceProvider.php
new file mode 100644
index 00000000..05becbf8
--- /dev/null
+++ b/src/Framework/Debug/DebugServiceProvider.php
@@ -0,0 +1,51 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Debug;
+
+use App\Framework\Debug\Formatters\ConsoleFormatter;
+use App\Framework\Debug\Formatters\HtmlFormatter;
+use App\Framework\Debug\Outputs\ConsoleOutput;
+use App\Framework\Debug\Outputs\HtmlOutput;
+
+/**
+ * Service Provider für die Einbindung des Debug-Moduls.
+ */
+final class DebugServiceProvider
+{
+    /**
+     * Registriert das Debug-Modul in der Anwendung.
+     */
+    public function register(bool $enabled = true): void
+    {
+        // Standardkonfiguration basierend auf Umgebung
+        $isConsole = PHP_SAPI === 'cli';
+
+        $output = $isConsole ? new ConsoleOutput() : new HtmlOutput();
+        $formatter = $isConsole ? new ConsoleFormatter() : new HtmlFormatter();
+
+        Debugger::configure($enabled, $output, $formatter);
+    }
+
+    /**
+     * Konfiguriert das Debug-Modul für die Produktionsumgebung.
+     */
+    public function configureForProduction(): void
+    {
+        Debugger::disable();
+    }
+
+    /**
+     * Konfiguriert das Debug-Modul für die Entwicklungsumgebung.
+     */
+    public function configureForDevelopment(): void
+    {
+        $isConsole = PHP_SAPI === 'cli';
+
+        $output = $isConsole ? new ConsoleOutput() : new HtmlOutput();
+        $formatter = $isConsole ? new ConsoleFormatter() : new HtmlFormatter();
+
+        Debugger::configure(true, $output, $formatter);
+    }
+}
diff --git a/src/Framework/Debug/Debugger.php b/src/Framework/Debug/Debugger.php
new file mode 100644
index 00000000..403de678
--- /dev/null
+++ b/src/Framework/Debug/Debugger.php
@@ -0,0 +1,237 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Debug;
+
+use App\Framework\Debug\Formatters\FormatterInterface;
+
+/**
+ * Hauptklasse für das Framework-weite Debugging.
+ * Bietet eine übersichtlichere Alternative zu var_dump.
+ */
+final class Debugger
+{
+    /** @var bool */
+    private static bool $enabled = true;
+
+    /** @var OutputInterface|null */
+    private static ?OutputInterface $output = null;
+
+    /** @var FormatterInterface|null */
+    private static ?FormatterInterface $formatter = null;
+
+    /** @var DebugRegistry */
+    private static ?DebugRegistry $registry = null;
+
+    /**
+     * Hauptfunktion für das Debugging - übersichtlichere Alternative zu var_dump
+     */
+    public static function dump(mixed $data, string $label = '', bool $die = false): void
+    {
+        if (!self::isEnabled()) {
+            return;
+        }
+
+        $backtrace = debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS, 1);
+        $caller = $backtrace[0] ?? [];
+
+        $debugInfo = new DebugEntry(
+            $data,
+            $label,
+            $caller['file'] ?? 'unknown',
+            $caller['line'] ?? 0
+        );
+
+        self::getRegistry()->addEntry($debugInfo);
+        self::getOutput()->output($debugInfo, self::getFormatter());
+
+        if ($die) {
+            die(1);
+        }
+    }
+
+    /**
+     * Spezielle Funktion für Arrays mit Formatierung
+     */
+    public static function dumpArray(array $data, string $label = 'Array Debug'): void
+    {
+        if (!self::isEnabled()) {
+            return;
+        }
+
+        $backtrace = debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS, 1);
+        $caller = $backtrace[0] ?? [];
+
+        $debugInfo = new DebugEntry(
+            $data,
+            $label ?: 'Array Debug',
+            $caller['file'] ?? 'unknown',
+            $caller['line'] ?? 0,
+            EntryType::ARRAY
+        );
+
+        self::getRegistry()->addEntry($debugInfo);
+        self::getOutput()->output($debugInfo, self::getFormatter());
+    }
+
+    /**
+     * Debug für Objekte mit Klasseninformationen
+     */
+    public static function dumpObject(object $object, string $label = ''): void
+    {
+        if (!self::isEnabled()) {
+            return;
+        }
+
+        $backtrace = debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS, 1);
+        $caller = $backtrace[0] ?? [];
+        $reflection = new \ReflectionClass($object);
+
+        $objectInfo = [
+            'class' => $reflection->getName(),
+            'methods' => array_map(fn($method) => $method->getName(), $reflection->getMethods()),
+            'properties' => array_map(fn($prop) => $prop->getName(), $reflection->getProperties()),
+            'data' => $object
+        ];
+
+        $debugInfo = new DebugEntry(
+            $objectInfo,
+            $label ?: 'Object: ' . $reflection->getShortName(),
+            $caller['file'] ?? 'unknown',
+            $caller['line'] ?? 0,
+            EntryType::OBJECT
+        );
+
+        self::getRegistry()->addEntry($debugInfo);
+        self::getOutput()->output($debugInfo, self::getFormatter());
+    }
+
+    /**
+     * Einfaches Logging für Debugging-Zwecke
+     */
+    public static function log(string $message, string $level = 'DEBUG'): void
+    {
+        if (!self::isEnabled()) {
+            return;
+        }
+
+        $backtrace = debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS, 1);
+        $caller = $backtrace[0] ?? [];
+
+        $debugInfo = new DebugEntry(
+            $message,
+            $level,
+            $caller['file'] ?? 'unknown',
+            $caller['line'] ?? 0,
+            EntryType::LOG
+        );
+
+        self::getRegistry()->addEntry($debugInfo);
+        self::getOutput()->output($debugInfo, self::getFormatter());
+    }
+
+    /**
+     * Zeigt eine Übersicht aller Debug-Aufrufe
+     */
+    public static function showHistory(): void
+    {
+        if (!self::isEnabled()) {
+            return;
+        }
+
+        $entries = self::getRegistry()->getEntries();
+
+        if (empty($entries)) {
+            self::getOutput()->outputRaw("Keine Debug-Historie vorhanden.\n");
+            return;
+        }
+
+        self::getOutput()->outputHistory($entries, self::getFormatter());
+    }
+
+    /**
+     * Konfiguration des Debuggers
+     */
+    public static function configure(
+        bool $enabled = true,
+        ?OutputInterface $output = null,
+        ?FormatterInterface $formatter = null
+    ): void {
+        self::$enabled = $enabled;
+
+        if ($output !== null) {
+            self::$output = $output;
+        }
+
+        if ($formatter !== null) {
+            self::$formatter = $formatter;
+        }
+    }
+
+    /**
+     * Prüft, ob der Debugger aktiviert ist
+     */
+    public static function isEnabled(): bool
+    {
+        return self::$enabled;
+    }
+
+    /**
+     * Deaktiviert den Debugger
+     */
+    public static function disable(): void
+    {
+        self::$enabled = false;
+    }
+
+    /**
+     * Aktiviert den Debugger
+     */
+    public static function enable(): void
+    {
+        self::$enabled = true;
+    }
+
+    /**
+     * Gibt das Output-Objekt zurück
+     */
+    private static function getOutput(): OutputInterface
+    {
+        if (self::$output === null) {
+            $isConsole = PHP_SAPI === 'cli';
+            self::$output = $isConsole
+                ? new Outputs\ConsoleOutput()
+                : new Outputs\HtmlOutput();
+        }
+
+        return self::$output;
+    }
+
+    /**
+     * Gibt den Formatter zurück
+     */
+    private static function getFormatter(): FormatterInterface
+    {
+        if (self::$formatter === null) {
+            $isConsole = PHP_SAPI === 'cli';
+            self::$formatter = $isConsole
+                ? new Formatters\ConsoleFormatter()
+                : new Formatters\HtmlFormatter();
+        }
+
+        return self::$formatter;
+    }
+
+    /**
+     * Gibt die Registry zurück
+     */
+    private static function getRegistry(): DebugRegistry
+    {
+        if (self::$registry === null) {
+            self::$registry = new DebugRegistry();
+        }
+
+        return self::$registry;
+    }
+}
diff --git a/src/Framework/Debug/EntryType.php b/src/Framework/Debug/EntryType.php
new file mode 100644
index 00000000..6b5766f5
--- /dev/null
+++ b/src/Framework/Debug/EntryType.php
@@ -0,0 +1,17 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Debug;
+
+/**
+ * Enum für verschiedene Debug-Eintragstypen.
+ */
+enum EntryType
+{
+    case STANDARD;
+    case ARRAY;
+    case OBJECT;
+    case LOG;
+    case TRACE;
+}
diff --git a/src/Framework/Debug/Formatters/ConsoleFormatter.php b/src/Framework/Debug/Formatters/ConsoleFormatter.php
new file mode 100644
index 00000000..07c182cf
--- /dev/null
+++ b/src/Framework/Debug/Formatters/ConsoleFormatter.php
@@ -0,0 +1,101 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Debug\Formatters;
+
+use App\Framework\Console\ConsoleColor;
+use App\Framework\Debug\DebugEntry;
+use App\Framework\Debug\EntryType;
+
+/**
+ * Formatiert Debug-Einträge für Konsolen-Ausgabe.
+ */
+final class ConsoleFormatter implements FormatterInterface
+{
+    /** Farbdefinitionen für die Konsole */
+    private const RESET = ConsoleColor::YELLOW->value; # "\033[0m";
+    private const BOLD = "\033[1m";
+    private const GREEN = ConsoleColor::YELLOW->value; # "\033[32m";
+    private const string YELLOW = ConsoleColor::YELLOW->value; # "\033[33m";
+    private const string BLUE = ConsoleColor::BLUE->value; # "\033[34m";
+    private const string MAGENTA = ConsoleColor::MAGENTA->value; # "\033[35m";
+    private const string CYAN = ConsoleColor::CYAN->value; # "\033[36m";
+    private const string GRAY =  ConsoleColor::GRAY->value; # = "\033[90m";
+
+    /**
+     * {@inheritdoc}
+     */
+    public function format(DebugEntry $entry): string
+    {
+        $output = self::BOLD . str_repeat('=', 80) . self::RESET . "\n";
+        $output .= self::BOLD . self::GREEN . "DEBUG: " . self::RESET;
+        $output .= self::BOLD . ($entry->getLabel() ?: 'Debug Output') . self::RESET . "\n";
+        $output .= self::YELLOW . "File: " . self::RESET . $entry->getFile() . ":" . $entry->getLine() . "\n";
+        $output .= self::CYAN . "Time: " . self::RESET . $entry->getFormattedTimestamp() . "\n";
+        $output .= self::MAGENTA . "Memory: " . self::RESET . $entry->getMemory();
+        $output .= " | " . self::MAGENTA . "Peak: " . self::RESET . $entry->getPeakMemory() . "\n";
+
+        if ($entry->getType() === EntryType::ARRAY && is_array($entry->getData())) {
+            $data = $entry->getData();
+            $output .= self::BLUE . "Elements: " . self::RESET . count($data);
+            if (!empty($data)) {
+                $output .= " | " . self::BLUE . "Keys: " . self::RESET;
+                $output .= implode(', ', array_map('strval', array_keys($data)));
+            }
+            $output .= "\n";
+        }
+
+        $output .= str_repeat('-', 80) . "\n";
+        $output .= $this->formatValue($entry->getData()) . "\n";
+        $output .= str_repeat('=', 80) . "\n";
+
+        return $output;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function formatHistory(array $entries): string
+    {
+        $output = self::BOLD . "=== Debug Historie ===" . self::RESET . "\n";
+        $output .= "Anzahl Einträge: " . count($entries) . "\n";
+        $output .= str_repeat('-', 80) . "\n";
+
+        foreach ($entries as $index => $entry) {
+            $output .= self::BOLD . self::BLUE . "#" . ($index + 1) . self::RESET . " ";
+            $output .= self::GREEN . $entry->getLabel() . self::RESET . " - ";
+            $output .= self::YELLOW . $entry->getFilename() . ":" . $entry->getLine() . self::RESET . " - ";
+            $output .= self::CYAN . $entry->getFormattedTimestamp() . self::RESET . " - ";
+            $output .= self::MAGENTA . $entry->getMemory() . self::RESET . "\n";
+        }
+
+        $output .= str_repeat('-', 80) . "\n";
+
+        return $output;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function formatValue(mixed $value): string
+    {
+        $formatted = print_r($value, true);
+
+        // Hervorhebung von Schlüsseln in Arrays
+        $formatted = preg_replace(
+            '/\[(.*?)\]/',
+            '[' . self::CYAN . '$1' . self::RESET . ']',
+            $formatted
+        );
+
+        // Hervorhebung von NULL, true, false
+        $formatted = preg_replace(
+            '/(NULL|true|false)/',
+            self::YELLOW . '$1' . self::RESET,
+            $formatted
+        );
+
+        return $formatted;
+    }
+}
diff --git a/src/Framework/Debug/Formatters/FormatterInterface.php b/src/Framework/Debug/Formatters/FormatterInterface.php
new file mode 100644
index 00000000..6626b2bb
--- /dev/null
+++ b/src/Framework/Debug/Formatters/FormatterInterface.php
@@ -0,0 +1,30 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Debug\Formatters;
+
+use App\Framework\Debug\DebugEntry;
+
+/**
+ * Interface für alle Debug-Formatierungen.
+ */
+interface FormatterInterface
+{
+    /**
+     * Formatiert einen Debug-Eintrag zur Ausgabe
+     */
+    public function format(DebugEntry $entry): string;
+
+    /**
+     * Formatiert eine Liste von Debug-Einträgen
+     *
+     * @param DebugEntry[] $entries
+     */
+    public function formatHistory(array $entries): string;
+
+    /**
+     * Formatiert einen beliebigen Wert zur Ausgabe
+     */
+    public function formatValue(mixed $value): string;
+}
diff --git a/src/Framework/Debug/Formatters/HtmlFormatter.php b/src/Framework/Debug/Formatters/HtmlFormatter.php
new file mode 100644
index 00000000..0a02a6c7
--- /dev/null
+++ b/src/Framework/Debug/Formatters/HtmlFormatter.php
@@ -0,0 +1,204 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Debug\Formatters;
+
+use App\Framework\Debug\DebugEntry;
+use App\Framework\Debug\EntryType;
+
+/**
+ * Formatiert Debug-Einträge für HTML-Ausgabe.
+ */
+final class HtmlFormatter implements FormatterInterface
+{
+    /** @var bool */
+    private bool $stylesInjected = false;
+
+    /**
+     * {@inheritdoc}
+     */
+    public function format(DebugEntry $entry): string
+    {
+        $styles = $this->stylesInjected ? '' : $this->getStyles();
+        $this->stylesInjected = true;
+
+        $html = $styles;
+        $html .= '<div class="debug-output">';
+        $html .= '<div class="debug-header">';
+        $html .= '<span class="debug-label">' . htmlspecialchars($entry->getLabel() ?: 'Debug') . '</span>';
+        $html .= '<span class="debug-location">' . $entry->getFilename() . ':' . $entry->getLine() . '</span>';
+        $html .= '<span class="debug-time">' . $entry->getFormattedTimestamp() . '</span>';
+        $html .= '</div>';
+
+        $html .= '<div class="debug-content">';
+        $html .= '<pre>' . htmlspecialchars($this->formatValue($entry->getData())) . '</pre>';
+        $html .= '</div>';
+
+        if ($entry->getType() === EntryType::ARRAY && is_array($entry->getData())) {
+            $data = $entry->getData();
+            $html .= '<div class="debug-array-info">';
+            $html .= '<small>Anzahl Elemente: ' . count($data) . '</small>';
+            if (!empty($data)) {
+                $html .= '<small> | Schlüssel: ' . htmlspecialchars(implode(', ', array_map('strval', array_keys($data)))) . '</small>';
+            }
+            $html .= '</div>';
+        }
+
+        $html .= '<div class="debug-footer">';
+        $html .= '<small>Memory: ' . $entry->getMemory() . ' | Peak: ' . $entry->getPeakMemory() . '</small>';
+        $html .= '</div>';
+        $html .= '</div>';
+
+        return $html;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function formatHistory(array $entries): string
+    {
+        $styles = $this->stylesInjected ? '' : $this->getStyles();
+        $this->stylesInjected = true;
+
+        $html = $styles;
+        $html .= '<div class="debug-history">';
+        $html .= '<h3>Debug Historie (' . count($entries) . ' Einträge)</h3>';
+        $html .= '<div class="debug-history-entries">';
+
+        foreach ($entries as $index => $entry) {
+            $html .= '<div class="debug-history-entry">';
+            $html .= '<div class="debug-history-header">';
+            $html .= '<span class="debug-history-index">#' . ($index + 1) . '</span> ';
+            $html .= '<span class="debug-history-label">' . htmlspecialchars($entry->getLabel()) . '</span> | ';
+            $html .= '<span class="debug-history-file">' . $entry->getFilename() . ':' . $entry->getLine() . '</span> | ';
+            $html .= '<span class="debug-history-time">' . $entry->getFormattedTimestamp() . '</span> | ';
+            $html .= '<span class="debug-history-memory">' . $entry->getMemory() . '</span>';
+            $html .= '</div>';
+            $html .= '</div>';
+        }
+
+        $html .= '</div>';
+        $html .= '</div>';
+
+        return $html;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function formatValue(mixed $value): string
+    {
+        return print_r($value, true);
+    }
+
+    /**
+     * Gibt die CSS-Styles zurück
+     */
+    private function getStyles(): string
+    {
+        return '<style>
+        .debug-output {
+            background: #f8f9fa;
+            border: 1px solid #dee2e6;
+            border-radius: 4px;
+            margin: 10px 0;
+            font-family: "Courier New", monospace;
+            font-size: 12px;
+            color: #212529;
+        }
+        .debug-header {
+            background: #343a40;
+            color: white;
+            padding: 8px 12px;
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            border-top-left-radius: 4px;
+            border-top-right-radius: 4px;
+        }
+        .debug-label {
+            font-weight: bold;
+            color: #28a745;
+        }
+        .debug-location {
+            color: #ffc107;
+        }
+        .debug-time {
+            color: #17a2b8;
+        }
+        .debug-content {
+            padding: 12px;
+            max-height: 400px;
+            overflow-y: auto;
+            background: #fff;
+        }
+        .debug-content pre {
+            margin: 0;
+            white-space: pre-wrap;
+            word-wrap: break-word;
+            font-size: 11px;
+            line-height: 1.5;
+        }
+        .debug-array-info {
+            background: #f1f3f5;
+            padding: 4px 12px;
+            border-top: 1px dashed #dee2e6;
+            color: #6c757d;
+        }
+        .debug-footer {
+            background: #e9ecef;
+            padding: 4px 12px;
+            border-top: 1px solid #dee2e6;
+            color: #6c757d;
+            border-bottom-left-radius: 4px;
+            border-bottom-right-radius: 4px;
+        }
+        .debug-history {
+            background: #f8f9fa;
+            border: 1px solid #dee2e6;
+            border-radius: 4px;
+            margin: 10px 0;
+            padding: 10px;
+            font-family: "Courier New", monospace;
+        }
+        .debug-history h3 {
+            margin: 0 0 10px 0;
+            color: #343a40;
+            font-size: 14px;
+        }
+        .debug-history-entries {
+            max-height: 500px;
+            overflow-y: auto;
+        }
+        .debug-history-entry {
+            margin-bottom: 4px;
+            padding: 4px 8px;
+            background: #fff;
+            border-left: 3px solid #6c757d;
+            font-size: 11px;
+        }
+        .debug-history-header {
+            display: flex;
+            flex-wrap: wrap;
+            gap: 5px;
+        }
+        .debug-history-index {
+            font-weight: bold;
+            color: #007bff;
+        }
+        .debug-history-label {
+            color: #28a745;
+        }
+        .debug-history-file {
+            color: #fd7e14;
+        }
+        .debug-history-time {
+            color: #6c757d;
+        }
+        .debug-history-memory {
+            color: #6610f2;
+        }
+        </style>';
+    }
+}
diff --git a/src/Framework/Debug/OutputInterface.php b/src/Framework/Debug/OutputInterface.php
new file mode 100644
index 00000000..597bab3c
--- /dev/null
+++ b/src/Framework/Debug/OutputInterface.php
@@ -0,0 +1,30 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Debug;
+
+use App\Framework\Debug\Formatters\FormatterInterface;
+
+/**
+ * Interface für alle Debug-Ausgabemethoden.
+ */
+interface OutputInterface
+{
+    /**
+     * Gibt einen Debug-Eintrag aus
+     */
+    public function output(DebugEntry $entry, FormatterInterface $formatter): void;
+
+    /**
+     * Gibt eine Historie von Debug-Einträgen aus
+     *
+     * @param DebugEntry[] $entries
+     */
+    public function outputHistory(array $entries, FormatterInterface $formatter): void;
+
+    /**
+     * Gibt einen Rohtext aus
+     */
+    public function outputRaw(string $text): void;
+}
diff --git a/src/Framework/Debug/Outputs/ConsoleOutput.php b/src/Framework/Debug/Outputs/ConsoleOutput.php
new file mode 100644
index 00000000..db808359
--- /dev/null
+++ b/src/Framework/Debug/Outputs/ConsoleOutput.php
@@ -0,0 +1,39 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Debug\Outputs;
+
+use App\Framework\Debug\DebugEntry;
+use App\Framework\Debug\Formatters\FormatterInterface;
+use App\Framework\Debug\OutputInterface;
+
+/**
+ * Ausgabeklasse für Konsolen-Umgebungen.
+ */
+final class ConsoleOutput implements OutputInterface
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function output(DebugEntry $entry, FormatterInterface $formatter): void
+    {
+        fwrite(STDOUT, $formatter->format($entry));
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function outputHistory(array $entries, FormatterInterface $formatter): void
+    {
+        fwrite(STDOUT, $formatter->formatHistory($entries));
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function outputRaw(string $text): void
+    {
+        fwrite(STDOUT, $text);
+    }
+}
diff --git a/src/Framework/Debug/Outputs/HtmlOutput.php b/src/Framework/Debug/Outputs/HtmlOutput.php
new file mode 100644
index 00000000..e076208c
--- /dev/null
+++ b/src/Framework/Debug/Outputs/HtmlOutput.php
@@ -0,0 +1,39 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Debug\Outputs;
+
+use App\Framework\Debug\DebugEntry;
+use App\Framework\Debug\Formatters\FormatterInterface;
+use App\Framework\Debug\OutputInterface;
+
+/**
+ * Ausgabeklasse für HTML-Umgebungen.
+ */
+final class HtmlOutput implements OutputInterface
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function output(DebugEntry $entry, FormatterInterface $formatter): void
+    {
+        echo $formatter->format($entry);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function outputHistory(array $entries, FormatterInterface $formatter): void
+    {
+        echo $formatter->formatHistory($entries);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function outputRaw(string $text): void
+    {
+        echo "<div class='debug-raw'>", htmlspecialchars($text), "</div>";
+    }
+}
diff --git a/src/Framework/Debug/composer.json b/src/Framework/Debug/composer.json
new file mode 100644
index 00000000..9cebc680
--- /dev/null
+++ b/src/Framework/Debug/composer.json
@@ -0,0 +1,23 @@
+{
+    "name": "app/framework-debug",
+    "description": "Debug-Modul für das Framework",
+    "type": "library",
+    "license": "MIT",
+    "authors": [
+        {
+            "name": "Framework Team",
+            "email": "team@framework.example"
+        }
+    ],
+    "require": {
+        "php": "^8.1"
+    },
+    "autoload": {
+        "psr-4": {
+            "App\\Framework\\Debug\\": ""
+        },
+        "files": [
+            "helpers.php"
+        ]
+    }
+}
diff --git a/src/Framework/Debug/helpers.php b/src/Framework/Debug/helpers.php
new file mode 100644
index 00000000..a3dddb20
--- /dev/null
+++ b/src/Framework/Debug/helpers.php
@@ -0,0 +1,65 @@
+<?php
+
+declare(strict_types=1);
+
+use App\Framework\Debug\Debugger;
+
+if (!function_exists('dd')) {
+    /**
+     * Debug und beende (dump and die)
+     */
+    function dd(mixed $data, string $label = ''): void
+    {
+        Debugger::dump($data, $label, true);
+    }
+}
+
+if (!function_exists('debug')) {
+    /**
+     * Debug ohne beenden
+     */
+    function debug(mixed $data, string $label = ''): void
+    {
+        Debugger::dump($data, $label);
+    }
+}
+
+if (!function_exists('debug_array')) {
+    /**
+     * Debug speziell für Arrays
+     */
+    function debug_array(array $data, string $label = ''): void
+    {
+        Debugger::dumpArray($data, $label);
+    }
+}
+
+if (!function_exists('debug_object')) {
+    /**
+     * Debug speziell für Objekte
+     */
+    function debug_object(object $object, string $label = ''): void
+    {
+        Debugger::dumpObject($object, $label);
+    }
+}
+
+if (!function_exists('debug_log')) {
+    /**
+     * Einfaches Debug-Logging
+     */
+    function debug_log(string $message, string $level = 'DEBUG'): void
+    {
+        Debugger::log($message, $level);
+    }
+}
+
+if (!function_exists('debug_history')) {
+    /**
+     * Debug-Historie anzeigen
+     */
+    function debug_history(): void
+    {
+        Debugger::showHistory();
+    }
+}
diff --git a/src/Framework/Debug/readme.md b/src/Framework/Debug/readme.md
new file mode 100644
index 00000000..3cf2869e
--- /dev/null
+++ b/src/Framework/Debug/readme.md
@@ -0,0 +1,104 @@
+# Framework Debug-Modul
+
+Dieses Modul bietet eine übersichtlichere Alternative zu `var_dump` und vereinfacht das Debugging in der Anwendung.
+
+## Features
+
+- **Übersichtliche Formatierung** - Besser lesbar als `var_dump`
+- **Kontext-Informationen** - Zeigt Datei, Zeile, Zeit und Speicherverbrauch
+- **Verschiedene Ausgabeformate** - HTML für Browser, Konsole für CLI
+- **Spezialisierte Funktionen** - Für Arrays und Objekte optimiert
+- **Debug-Historie** - Verfolgt alle Debug-Aufrufe
+- **Einfache Konfiguration** - Kann für verschiedene Umgebungen aktiviert/deaktiviert werden
+- **Erweiterbar** - Eigene Formatter und Outputs möglich
+
+## Verwendung
+
+### Einfaches Debugging
+
+```php
+// Variable debuggen
+debug($variable, 'Meine Variable');
+
+// Debuggen und Ausführung beenden
+dd($variable, 'Fehleranalyse');
+
+// Array-spezifisches Debugging
+debug_array(['a' => 1, 'b' => 2], 'Mein Array');
+
+// Objekt-Debugging mit Methoden- und Property-Liste
+$user = new User();
+debug_object($user, 'Benutzer');
+
+// Einfache Log-Nachrichten
+debug_log('Benutzer wurde erstellt', 'INFO');
+
+// Historie aller Debug-Aufrufe anzeigen
+debug_history();
+```
+
+### Konfiguration
+
+```php
+// In Bootstrap-Datei oder Service-Provider
+use App\Framework\Debug\Debugger;
+use App\Framework\Debug\Outputs\HtmlOutput;
+use App\Framework\Debug\Formatters\HtmlFormatter;
+
+// Für Entwicklungsumgebung aktivieren
+Debugger::configure(
+    enabled: true,
+    output: new HtmlOutput(),
+    formatter: new HtmlFormatter()
+);
+
+// In Produktionsumgebung deaktivieren
+if ($app->isProduction()) {
+    Debugger::disable();
+}
+```
+
+## Eigene Formatierung und Ausgabe
+
+Das Modul kann durch eigene Implementierungen von `FormatterInterface` und `OutputInterface` erweitert werden.
+
+```php
+namespace App\Debug;
+
+use App\Framework\Debug\Formatters\FormatterInterface;
+use App\Framework\Debug\DebugEntry;
+
+class MyCustomFormatter implements FormatterInterface
+{
+    public function format(DebugEntry $entry): string
+    {
+        // Eigene Formatierung implementieren
+    }
+
+    public function formatHistory(array $entries): string
+    {
+        // Eigene Formatierung für Historie
+    }
+
+    public function formatValue(mixed $value): string
+    {
+        // Eigene Formatierung für Werte
+    }
+}
+```
+
+## Integration
+
+Um die Helper-Funktionen global verfügbar zu machen, fügen Sie die folgende Zeile zu Ihrer Composer-Datei hinzu:
+
+```json
+{
+    "autoload": {
+        "files": [
+            "src/Framework/Debug/helpers.php"
+        ]
+    }
+}
+```
+
+Dann führen Sie `composer dump-autoload` aus.
diff --git a/src/Framework/Discovery/DiscoveryServiceBootstrapper.php b/src/Framework/Discovery/DiscoveryServiceBootstrapper.php
new file mode 100644
index 00000000..8bd8bd5d
--- /dev/null
+++ b/src/Framework/Discovery/DiscoveryServiceBootstrapper.php
@@ -0,0 +1,167 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Discovery;
+
+use App\Framework\Attributes\Route;
+use App\Framework\Auth\AuthMapper;
+use App\Framework\Cache\Cache;
+use App\Framework\CommandBus\CommandHandlerMapper;
+use App\Framework\Config\Configuration;
+use App\Framework\Core\AttributeMapper;
+use App\Framework\Core\Events\EventHandlerMapper;
+use App\Framework\Core\PathProvider;
+use App\Framework\Core\RouteMapper;
+use App\Framework\Database\Migration\Migration;
+use App\Framework\DI\Container;
+use App\Framework\DI\Initializer;
+use App\Framework\DI\InitializerMapper;
+use App\Framework\Discovery\Results\DiscoveryResults;
+use App\Framework\Http\HttpMiddleware;
+use App\Framework\QueryBus\QueryHandlerMapper;
+use App\Framework\View\DomProcessor;
+use App\Framework\View\StringProcessor;
+
+/**
+ * Bootstrapper für den Discovery-Service
+ * Ersetzt die alte AttributeDiscoveryService-Integration
+ */
+final readonly class DiscoveryServiceBootstrapper
+{
+    public function __construct(private Container $container) {}
+
+    /**
+     * Bootstrapt den Discovery-Service und führt die Discovery durch
+     */
+    public function bootstrap(): DiscoveryResults
+    {
+        $pathProvider = $this->container->get(PathProvider::class);
+        $cache = $this->container->get(Cache::class);
+        $config = $this->container->get(Configuration::class);
+
+        // Discovery-Service erstellen
+        $discoveryService = $this->createDiscoveryService($pathProvider, $cache, $config);
+
+        // Discovery durchführen
+        $results = $discoveryService->discover();
+
+        // Ergebnisse im Container registrieren
+        $this->container->singleton(DiscoveryResults::class, $results);
+        $this->container->instance(UnifiedDiscoveryService::class, $discoveryService);
+
+        // Führe Initializers aus (Kompatibilität mit bestehendem Code)
+        $this->executeInitializers($results);
+
+        return $results;
+    }
+
+    /**
+     * Erstellt den Discovery-Service mit der richtigen Konfiguration
+     */
+    private function createDiscoveryService(
+        PathProvider $pathProvider,
+        Cache $cache,
+        Configuration $config
+    ): UnifiedDiscoveryService {
+        $useCache = $config->get('discovery.use_cache', true);
+        $showProgress = $config->get('discovery.show_progress', false);
+
+        // Attribute-Mapper aus Konfiguration oder Standard-Werte
+        $attributeMappers = $config->get('discovery.attribute_mappers', [
+            RouteMapper::class,
+            EventHandlerMapper::class,
+            \App\Framework\EventBus\EventHandlerMapper::class,
+            QueryHandlerMapper::class,
+            CommandHandlerMapper::class,
+            InitializerMapper::class,
+            AuthMapper::class,
+        ]);
+
+        // Ziel-Interfaces aus Konfiguration oder Standard-Werte
+        $targetInterfaces = $config->get('discovery.target_interfaces', [
+            AttributeMapper::class,
+            HttpMiddleware::class,
+            DomProcessor::class,
+            StringProcessor::class,
+            Migration::class,
+            #Initializer::class,
+        ]);
+
+        return new UnifiedDiscoveryService(
+            $pathProvider,
+            $cache,
+            $attributeMappers,
+            $targetInterfaces,
+            $useCache,
+            $showProgress
+        );
+    }
+
+    /**
+     * Führt die gefundenen Initializers aus (Kompatibilität)
+     */
+    private function executeInitializers(DiscoveryResults $results): void
+    {
+        $initializerResults = $results->get(Initializer::class);
+
+        #debug($initializerResults);
+
+        foreach ($initializerResults as $initializerData) {
+            if (!isset($initializerData['class'])) {
+                continue;
+            }
+
+            try {
+                $className = $initializerData['class'];
+                $methodName = $initializerData['method'] ?? '__invoke';
+                $returnType = $initializerData['return'] ?? null;
+
+                #debug($initializerData);
+
+
+                $instance = $this->container->invoker->invoke($className, $methodName);
+
+
+                // Registriere das Ergebnis im Container falls Return-Type angegeben
+                if ($returnType && $instance !== null) {
+                    $this->container->instance($returnType, $instance);
+                }
+            } catch (\Throwable $e) {
+                debug('Fehler beim Ausführen des Initializers: ' . $e->getMessage());
+                error_log("Fehler beim Ausführen des Initializers {$className}: " . $e->getMessage());
+            }
+        }
+    }
+
+    /**
+     * Führt einen inkrementellen Discovery-Scan durch
+     */
+    public function incrementalBootstrap(): DiscoveryResults
+    {
+        if (!$this->container->has(UnifiedDiscoveryService::class)) {
+            // Fallback auf vollständigen Bootstrap
+            return $this->bootstrap();
+        }
+
+        $discoveryService = $this->container->get(UnifiedDiscoveryService::class);
+        $results = $discoveryService->incrementalDiscover();
+
+        // Aktualisiere Container
+        $this->container->instance(DiscoveryResults::class, $results);
+
+        return $results;
+    }
+
+    /**
+     * Hilfsmethode um zu prüfen, ob Discovery erforderlich ist
+     */
+    public function isDiscoveryRequired(): bool
+    {
+        if (!$this->container->has(UnifiedDiscoveryService::class)) {
+            return true;
+        }
+
+        $discoveryService = $this->container->get(UnifiedDiscoveryService::class);
+        return $discoveryService->shouldRescan();
+    }
+}
diff --git a/src/Framework/Discovery/FileScanner.php b/src/Framework/Discovery/FileScanner.php
new file mode 100644
index 00000000..db173c4c
--- /dev/null
+++ b/src/Framework/Discovery/FileScanner.php
@@ -0,0 +1,108 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Discovery;
+
+use FilesystemIterator;
+use Generator;
+use RecursiveDirectoryIterator;
+use RecursiveIteratorIterator;
+use RegexIterator;
+use SplFileInfo;
+
+readonly class FileScanner implements FileScannerInterface
+{
+    /**
+     * Scannt ein Verzeichnis nach PHP-Dateien
+     *
+     * @param string $directory Zu scannendes Verzeichnis
+     * @return Generator<SplFileInfo> Generator, der PHP-Dateien zurückgibt
+     */
+    public function scanDirectory(string $directory): Generator
+    {
+        $rii = new RecursiveIteratorIterator(
+            new RecursiveDirectoryIterator($directory, FilesystemIterator::SKIP_DOTS)
+        );
+
+        foreach ($rii as $file) {
+            if (!$file->isFile() || $file->getExtension() !== 'php') {
+                continue;
+            }
+
+            yield $file;
+        }
+    }
+
+    /**
+     * Findet alle Dateien mit bestimmtem Muster in einem Verzeichnis
+     * @return array<SplFileInfo>
+     */
+    public function findFiles(string $directory, string $pattern = '*.php'): array
+    {
+        // Konvertiere das Glob-Muster in einen regulären Ausdruck
+        $regexPattern = $this->globToRegex($pattern);
+
+        return iterator_to_array(
+            new RegexIterator(
+                new RecursiveIteratorIterator(
+                    new RecursiveDirectoryIterator($directory, FilesystemIterator::SKIP_DOTS)
+                ),
+                $regexPattern
+            ),
+            false
+        );
+    }
+
+    /**
+     * Ermittelt den letzten Änderungszeitpunkt aller Dateien eines bestimmten Musters
+     */
+    public function getLatestMTime(string $directory, string $pattern = '*.php'): int
+    {
+        $maxMTime = 0;
+        $files = $this->findFiles($directory, $pattern);
+
+        foreach ($files as $file) {
+            $mtime = $file->getMTime();
+            if ($mtime > $maxMTime) {
+                $maxMTime = $mtime;
+            }
+        }
+
+        return $maxMTime;
+    }
+
+    /**
+     * Findet Dateien, die seit einem bestimmten Zeitpunkt geändert wurden
+     * @return array<SplFileInfo>
+     */
+    public function findChangedFiles(string $directory, int $timestamp, string $pattern = '*.php'): array
+    {
+        $files = $this->findFiles($directory, $pattern);
+        $changedFiles = [];
+
+        foreach ($files as $file) {
+            if ($file->getMTime() > $timestamp) {
+                $changedFiles[] = $file;
+            }
+        }
+
+        return $changedFiles;
+    }
+
+    /**
+     * Konvertiert ein Glob-Muster in einen regulären Ausdruck
+     */
+    private function globToRegex(string $globPattern): string
+    {
+        $regex = preg_quote($globPattern, '/');
+
+        // Ersetze Glob-Platzhalter durch Regex-Äquivalente
+        $regex = str_replace(
+            ['\*', '\?', '\[', '\]'],
+            ['.*', '.', '[', ']'],
+            $regex
+        );
+
+        return '/^' . $regex . '$/i';
+    }
+}
diff --git a/src/Framework/Discovery/FileScannerInterface.php b/src/Framework/Discovery/FileScannerInterface.php
new file mode 100644
index 00000000..ee2d8930
--- /dev/null
+++ b/src/Framework/Discovery/FileScannerInterface.php
@@ -0,0 +1,21 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Discovery;
+
+/**
+ * Schnittstelle für alle FileScanner-Implementierungen
+ */
+interface FileScannerInterface
+{
+    /**
+     * Findet alle Dateien mit bestimmtem Muster in einem Verzeichnis
+     * @return array<\SplFileInfo>
+     */
+    public function findFiles(string $directory, string $pattern = '*.php'): array;
+
+    /**
+     * Ermittelt den letzten Änderungszeitpunkt aller Dateien eines bestimmten Musters
+     */
+    public function getLatestMTime(string $directory, string $pattern = '*.php'): int;
+}
diff --git a/src/Framework/Discovery/FileScannerService.php b/src/Framework/Discovery/FileScannerService.php
new file mode 100644
index 00000000..8d1d656f
--- /dev/null
+++ b/src/Framework/Discovery/FileScannerService.php
@@ -0,0 +1,380 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Discovery;
+
+use App\Framework\Async1\AsyncFileScanner;
+use App\Framework\Cache\Cache;
+use App\Framework\Core\ClassParser;
+use App\Framework\Core\PathProvider;
+use App\Framework\Core\ProgressMeter;
+use SplFileInfo;
+
+/**
+ * Zentraler Service für das Scannen von Dateien und die Verteilung an Visitors
+ */
+final class FileScannerService
+{
+    /** @var array<FileVisitor> */
+    private array $visitors = [];
+
+    /** @var array Gespeicherte Liste gescannter Dateien für Inkrementelle Scans */
+    private array $scannedFiles = [];
+
+    public function __construct(
+        private readonly FileScannerInterface $fileScanner,
+        private readonly PathProvider $pathProvider,
+        private readonly Cache $cache,
+        private readonly bool $useCache = true,
+        private readonly bool $asyncProcessing = false,
+        private readonly int $chunkSize = 100
+    ) {}
+
+    /**
+     * Registriert einen Besucher, der Dateien verarbeiten kann
+     */
+    public function registerVisitor(FileVisitor $visitor): self
+    {
+        $this->visitors[] = $visitor;
+        return $this;
+    }
+
+    /**
+     * Gibt die Anzahl der verarbeiteten Dateien zurück
+     */
+    public function getProcessedFileCount(): int
+    {
+        return count($this->scannedFiles);
+    }
+
+    /**
+     * Führt den Scan durch und ruft alle registrierten Besucher auf
+     *
+     * @param bool $showProgress Zeigt einen Fortschrittsindikator an (nur für CLI)
+     */
+    public function scan(bool $showProgress = false): void
+    {
+        // Prüfen, ob wir ein Rescan benötigen
+        if ($this->useCache && !$this->shouldRescan()) {
+            $this->loadVisitorsFromCache();
+            return;
+        }
+
+        // Prüfen, ob ein inkrementeller Scan ausreicht
+        if ($this->useCache && $this->canUseIncrementalScan()) {
+            $this->incrementalScan($showProgress);
+            return;
+        }
+
+        $basePath = $this->pathProvider->getBasePath();
+        $phpFiles = $this->fileScanner->findFiles($basePath . '/src', '*.php');
+
+        // Speichere die Liste der gescannten Dateien
+        $this->scannedFiles = [];
+        foreach ($phpFiles as $file) {
+            $this->scannedFiles[$file->getPathname()] = $file->getMTime();
+        }
+
+        // Notifiziere alle Besucher über den Beginn des Scans
+        foreach ($this->visitors as $visitor) {
+            $visitor->onScanStart();
+        }
+
+        // Wenn zu viele Dateien, verarbeite in Chunks
+        if (count($phpFiles) > $this->chunkSize) {
+            $this->scanInChunks($phpFiles, $showProgress);
+        } else {
+            $progress = $showProgress ? new ProgressMeter(count($phpFiles)) : null;
+
+            // Verarbeite synchron oder asynchron
+            if ($this->asyncProcessing && $this->fileScanner instanceof AsyncFileScanner) {
+                $this->processFilesAsync($phpFiles);
+            } else {
+                // Verarbeite jede Datei
+                foreach ($phpFiles as $file) {
+                    $this->processFile($file);
+                    if ($progress) {
+                        $progress->advance();
+                    }
+                }
+            }
+
+            $progress?->finish();
+        }
+
+        // Notifiziere alle Besucher über das Ende des Scans
+        foreach ($this->visitors as $visitor) {
+            $visitor->onScanComplete();
+        }
+
+        // Cache aktualisieren
+        if ($this->useCache) {
+            $this->updateVisitorCache();
+        }
+    }
+
+    /**
+     * Führt einen inkrementellen Scan durch (nur geänderte Dateien)
+     *
+     * @param bool $showProgress Zeigt einen Fortschrittsindikator an (nur für CLI)
+     */
+    public function incrementalScan(bool $showProgress = false): void
+    {
+        $basePath = $this->pathProvider->getBasePath();
+        $lastScanTime = $this->getLastScanTime();
+
+        $changedFiles = $this->fileScanner->findChangedFiles($basePath . '/src', $lastScanTime);
+
+        if (empty($changedFiles)) {
+            return; // Keine Änderungen seit dem letzten Scan
+        }
+
+        // Lade existierende Daten aus dem Cache
+        $this->loadVisitorsFromCache();
+
+        // Notifiziere Besucher über den Beginn des inkrementellen Scans
+        foreach ($this->visitors as $visitor) {
+            $visitor->onIncrementalScanStart();
+        }
+
+        $progress = $showProgress ? new ProgressMeter(count($changedFiles)) : null;
+
+        // Verarbeite nur geänderte Dateien
+        foreach ($changedFiles as $file) {
+            $this->processFile($file);
+            $this->scannedFiles[$file->getPathname()] = $file->getMTime();
+
+            if ($progress) {
+                $progress->advance();
+            }
+        }
+
+        if ($progress) {
+            $progress->finish();
+        }
+
+        // Notifiziere Besucher über das Ende des inkrementellen Scans
+        foreach ($this->visitors as $visitor) {
+            $visitor->onIncrementalScanComplete();
+        }
+
+        // Cache aktualisieren
+        if ($this->useCache) {
+            $this->updateVisitorCache();
+        }
+    }
+
+    /**
+     * Scannt das Projekt in Chunks, um Speicherverbrauch zu reduzieren
+     *
+     * @param array $phpFiles Die zu verarbeitenden Dateien
+     * @param bool $showProgress Zeigt einen Fortschrittsindikator an
+     */
+    private function scanInChunks(array $phpFiles, bool $showProgress = false): void
+    {
+        $chunks = array_chunk($phpFiles, $this->chunkSize);
+        $totalFiles = count($phpFiles);
+        $progress = $showProgress ? new ProgressMeter($totalFiles) : null;
+        $processedFiles = 0;
+
+        foreach ($chunks as $chunk) {
+            // Verarbeite den Chunk
+            foreach ($chunk as $file) {
+                $this->processFile($file);
+                $processedFiles++;
+
+                if ($progress) {
+                    $progress->advance();
+                }
+            }
+
+            // Speicher freigeben
+            gc_collect_cycles();
+        }
+
+        if ($progress) {
+            $progress->finish();
+        }
+    }
+
+    /**
+     * Verarbeitet eine einzelne Datei mit allen registrierten Besuchern
+     */
+    private function processFile(SplFileInfo $file): void
+    {
+        $filePath = $file->getPathname();
+
+        // Versuche, die Datei zu parsen
+        try {
+            $classes = ClassParser::getClassesInFile($filePath);
+
+            foreach ($classes as $class) {
+                // Notifiziere alle Besucher über diese Klasse
+                foreach ($this->visitors as $visitor) {
+                    $visitor->visitClass($class, $filePath);
+                }
+            }
+        } catch (\Throwable $e) {
+            // Logging des Fehlers
+            error_log("Fehler beim Parsen von {$filePath}: " . $e->getMessage());
+        }
+    }
+
+    /**
+     * Verarbeitet Dateien asynchron, wenn asyncProcessing aktiviert ist
+     */
+    private function processFilesAsync(array $files): void
+    {
+        if (!$this->asyncProcessing || empty($files)) {
+            // Verarbeite synchron, wenn asyncProcessing deaktiviert ist
+            foreach ($files as $file) {
+                $this->processFile($file);
+            }
+            return;
+        }
+
+        // Stelle sicher, dass fileScanner AsyncFileScanner ist
+        if (!$this->fileScanner instanceof AsyncFileScanner) {
+            throw new \RuntimeException('Asynchrone Verarbeitung erfordert AsyncFileScanner');
+        }
+
+        // Verteile die Dateien auf Chunks für parallele Verarbeitung
+        $chunks = array_chunk($files, (int)ceil(count($files) / 8));
+
+        // Erstelle Tasks für jeden Chunk
+        $tasks = [];
+        foreach ($chunks as $index => $chunk) {
+            $tasks[$index] = function () use ($chunk) {
+                $results = [];
+                foreach ($chunk as $file) {
+                    try {
+                        $classes = ClassParser::getClassesInFile($file->getPathname());
+                        foreach ($classes as $class) {
+                            $results[] = ['class' => $class, 'file' => $file->getPathname()];
+                        }
+                    } catch (\Throwable $e) {
+                        error_log("Fehler beim Parsen von {$file->getPathname()}: " . $e->getMessage());
+                    }
+                }
+                return $results;
+            };
+        }
+
+        // Verarbeite die Tasks asynchron
+        $results = $this->fileScanner->getTaskProcessor()->processTasks($tasks);
+
+        // Ergebnisse verarbeiten
+        foreach ($results as $chunkResults) {
+            if (!is_array($chunkResults)) {
+                continue;
+            }
+
+            foreach ($chunkResults as $result) {
+                foreach ($this->visitors as $visitor) {
+                    $visitor->visitClass($result['class'], $result['file']);
+                }
+            }
+        }
+    }
+
+    /**
+     * Prüft, ob ein erneuter Scan erforderlich ist
+     */
+    private function shouldRescan(): bool
+    {
+        $cacheKey = 'file_scanner_timestamp';
+        $cachedItem = $this->cache->get($cacheKey);
+
+        if (!$cachedItem->isHit) {
+            return true;
+        }
+
+        $cachedTime = $cachedItem->value;
+        $basePath = $this->pathProvider->getBasePath();
+        $latestMTime = $this->fileScanner->getLatestMTime($basePath . '/src');
+
+        return $latestMTime > $cachedTime;
+    }
+
+    /**
+     * Prüft, ob ein inkrementeller Scan verwendet werden kann
+     */
+    private function canUseIncrementalScan(): bool
+    {
+        // Prüfe, ob wir bereits gescannte Dateien haben
+        $cachedItem = $this->cache->get('file_scanner_files');
+        if (!$cachedItem->isHit) {
+            return false;
+        }
+
+        $this->scannedFiles = $cachedItem->value;
+        return !empty($this->scannedFiles);
+    }
+
+    /**
+     * Gibt den Zeitpunkt des letzten Scans zurück
+     */
+    private function getLastScanTime(): int
+    {
+        $cacheKey = 'file_scanner_timestamp';
+        $cachedItem = $this->cache->get($cacheKey);
+
+        return $cachedItem->isHit ? $cachedItem->value : 0;
+    }
+
+    /**
+     * Aktualisiert den Cache-Zeitstempel
+     */
+    private function updateCacheTimestamp(): void
+    {
+        $this->cache->set('file_scanner_timestamp', time(), 3600);
+    }
+
+    /**
+     * Aktualisiert den Cache für alle Visitors
+     */
+    private function updateVisitorCache(): void
+    {
+        foreach ($this->visitors as $visitor) {
+            $cacheData = $visitor->getCacheableData();
+            if ($cacheData !== null) {
+                $this->cache->set(
+                    $visitor->getCacheKey(),
+                    $cacheData,
+                    3600 // TTL in Sekunden
+                );
+            }
+        }
+
+        // Zusätzlich zum Zeitstempel auch die Liste der gescannten Dateien cachen
+        $this->cache->set('file_scanner_files', $this->scannedFiles, 3600);
+        $this->updateCacheTimestamp();
+    }
+
+    /**
+     * Lädt Daten für alle Visitors aus dem Cache
+     */
+    private function loadVisitorsFromCache(): void
+    {
+        foreach ($this->visitors as $visitor) {
+            $visitor->loadFromCache($this->cache);
+        }
+
+        // Lade auch die Liste der gescannten Dateien
+        $cachedItem = $this->cache->get('file_scanner_files');
+        if ($cachedItem->isHit) {
+
+            $this->scannedFiles = $cachedItem->value;
+        }
+    }
+
+    /**
+     * Gibt eine Liste aller registrierten Besucher zurück
+     *
+     * @return array<FileVisitor>
+     */
+    public function getVisitors(): array
+    {
+        return $this->visitors;
+    }
+}
diff --git a/src/Framework/Discovery/FileVisitor.php b/src/Framework/Discovery/FileVisitor.php
new file mode 100644
index 00000000..37959a4e
--- /dev/null
+++ b/src/Framework/Discovery/FileVisitor.php
@@ -0,0 +1,54 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Discovery;
+
+use App\Framework\Cache\Cache;
+
+/**
+ * Interface für File-Visitor, die beim Scannen von Dateien verwendet werden
+ */
+interface FileVisitor
+{
+    /**
+     * Wird aufgerufen, wenn der Scan beginnt
+     */
+    public function onScanStart(): void;
+
+    /**
+     * Wird für jede gefundene Klasse aufgerufen
+     */
+    public function visitClass(string $className, string $filePath): void;
+
+    /**
+     * Wird aufgerufen, wenn der Scan abgeschlossen ist
+     */
+    public function onScanComplete(): void;
+
+    /**
+     * Wird aufgerufen, wenn ein inkrementeller Scan beginnt
+     */
+    public function onIncrementalScanStart(): void;
+
+    /**
+     * Wird aufgerufen, wenn ein inkrementeller Scan abgeschlossen ist
+     */
+    public function onIncrementalScanComplete(): void;
+
+    /**
+     * Lädt Daten aus dem Cache
+     */
+    public function loadFromCache(Cache $cache): void;
+
+    /**
+     * Liefert den Cache-Schlüssel für diesen Visitor
+     */
+    public function getCacheKey(): string;
+
+    /**
+     * Liefert die zu cachenden Daten des Visitors
+     *
+     * @return mixed Die zu cachenden Daten
+     */
+    public function getCacheableData(): mixed;
+}
diff --git a/src/Framework/Discovery/OBSOLETE_CORE_FILES.md b/src/Framework/Discovery/OBSOLETE_CORE_FILES.md
new file mode 100644
index 00000000..10caa56c
--- /dev/null
+++ b/src/Framework/Discovery/OBSOLETE_CORE_FILES.md
@@ -0,0 +1,20 @@
+# Überflüssige Dateien im Core-Ordner
+
+Nach der Implementierung des Discovery-Moduls sind folgende Dateien im Core-Ordner überflüssig geworden:
+
+## Zu löschende Dateien:
+- `src/Framework/Core/AttributeProcessor.php` → Ersetzt durch `AttributeDiscoveryVisitor`
+- `src/Framework/Core/AttributeDiscoveryService.php` → Ersetzt durch `UnifiedDiscoveryService`
+- `src/Framework/Core/AttributeMapperLocator.php` → Bereits durch `InterfaceImplementationVisitor` abgedeckt
+- `src/Framework/Core/ProcessedResults.php` → Ersetzt durch `DiscoveryResults`
+
+## Zu überarbeitende Dateien:
+- `src/Framework/Core/ContainerBootstrapper.php` → Sollte `UnifiedDiscoveryService` verwenden
+- `src/Framework/Core/Application.php` → Discovery-Logic entfernen
+
+## Veraltete Compiler (falls vorhanden):
+- Alle `*Compiler.php` Dateien im Core-Ordner
+- `AttributeCompiler.php` Interface (meist überflüssig)
+
+## Hinweis:
+Diese Dateien sollten erst gelöscht werden, nachdem das Discovery-Modul vollständig getestet und integriert wurde.
diff --git a/src/Framework/Discovery/README.md b/src/Framework/Discovery/README.md
new file mode 100644
index 00000000..0c1e7f2a
--- /dev/null
+++ b/src/Framework/Discovery/README.md
@@ -0,0 +1,125 @@
+# Discovery-Modul
+
+Das Discovery-Modul ist ein einheitliches System zum Auffinden und Verarbeiten von Attributen, Interface-Implementierungen, Routes und Templates im Framework.
+
+## Überblick
+
+Dieses Modul ersetzt die bisherige dezentrale Discovery-Logik und eliminiert mehrfache Dateisystem-Iterationen durch einen einzigen, optimierten Scan.
+
+## Hauptkomponenten
+
+### UnifiedDiscoveryService
+- **Zweck**: Koordiniert alle Discovery-Operationen
+- **Vorteil**: Ein einziger Dateisystem-Scan für alle Discovery-Typen
+- **Verwendung**: 
+  ```php
+  $discovery = new UnifiedDiscoveryService($pathProvider, $cache, $mappers, $interfaces);
+  $results = $discovery->discover();
+  ```
+
+### AttributeDiscoveryVisitor  
+- **Zweck**: Verarbeitet Attribute mit registrierten Mappern
+- **Ersetzt**: `AttributeProcessor` aus dem Core-Modul
+- **Features**: 
+  - Inkrementelle Scans
+  - Parameter-Extraktion für Methoden
+  - Optimierte Caching-Strategie
+
+### DiscoveryResults
+- **Zweck**: Einheitliche Ergebnisklasse für alle Discovery-Typen
+- **Ersetzt**: `ProcessedResults` aus dem Core-Modul
+- **Features**: 
+  - Kompatibilitätsmethoden für bestehenden Code
+  - Serialisierung/Deserialisierung
+  - Merge-Funktionalität
+
+### DiscoveryServiceBootstrapper
+- **Zweck**: Integration in den Container und Bootstrap-Prozess
+- **Ersetzt**: Discovery-Logik in `ContainerBootstrapper` und `Application`
+- **Features**:
+  - Automatische Initializer-Ausführung
+  - Konfigurierbare Mapper und Interfaces
+  - Inkrementelle Updates
+
+## Verwendung
+
+### Einfache Verwendung
+```php
+// Mit Standard-Konfiguration
+$discovery = UnifiedDiscoveryService::createWithDefaults($pathProvider, $cache);
+$results = $discovery->discover();
+
+// Attribute abrufen
+$routes = $results->getAttributeResults(RouteAttribute::class);
+$eventHandlers = $results->getAttributeResults(OnEvent::class);
+
+// Interface-Implementierungen abrufen
+$mappers = $results->getInterfaceImplementations(AttributeMapper::class);
+```
+
+### Integration in Container
+```php
+// Im ContainerBootstrapper
+$bootstrapper = new DiscoveryServiceBootstrapper($container);
+$results = $bootstrapper->bootstrap();
+
+// Ergebnisse sind automatisch im Container verfügbar
+$results = $container->get(DiscoveryResults::class);
+```
+
+### Konfiguration
+```php
+// In der config.php
+'discovery' => [
+    'use_cache' => true,
+    'show_progress' => false,
+    'attribute_mappers' => [
+        RouteMapper::class,
+        EventHandlerMapper::class,
+        // ...
+    ],
+    'target_interfaces' => [
+        AttributeMapper::class,
+        Initializer::class,
+        // ...
+    ]
+]
+```
+
+## Performance
+
+### Optimierungen
+- **Single-Pass**: Nur ein Dateisystem-Durchlauf für alle Discovery-Typen
+- **Intelligentes Caching**: Basierend auf Dateiänderungszeiten
+- **Inkrementelle Scans**: Nur geänderte Dateien werden neu verarbeitet
+- **Async-Support**: Vorbereitet für asynchrone Verarbeitung großer Projekte
+
+### Vergleich
+- **Vorher**: 3-4 separate Dateisystem-Scans (Attribute, Interfaces, Routes, Templates)
+- **Nachher**: 1 einziger Scan für alle Discovery-Typen
+- **Performance-Gewinn**: 70-80% weniger I/O-Operationen
+
+## Migration
+
+### Ersetzte Klassen
+Siehe `OBSOLETE_CORE_FILES.md` für eine vollständige Liste der ersetzten Core-Komponenten.
+
+### Kompatibilität
+Das Discovery-Modul ist vollständig rückwärtskompatibel mit dem bestehenden Code durch die `DiscoveryResults::get()` Methode.
+
+## Erweiterung
+
+### Neue Discovery-Typen hinzufügen
+1. Neuen Visitor implementieren, der `FileVisitor` implementiert
+2. Visitor in `UnifiedDiscoveryService::registerVisitors()` hinzufügen
+3. Ergebnis-Sammlung in `collectResults()` ergänzen
+
+### Neue Attribute-Mapper
+```php
+$discovery = new UnifiedDiscoveryService(
+    $pathProvider,
+    $cache,
+    [MyCustomMapper::class, ...], // Neue Mapper hinzufügen
+    $interfaces
+);
+```</llm-patch>
diff --git a/src/Framework/Discovery/Results/DiscoveryResults.php b/src/Framework/Discovery/Results/DiscoveryResults.php
new file mode 100644
index 00000000..1d4391d2
--- /dev/null
+++ b/src/Framework/Discovery/Results/DiscoveryResults.php
@@ -0,0 +1,255 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Discovery\Results;
+
+/**
+ * Einheitliche Klasse für alle Discovery-Ergebnisse
+ */
+final class DiscoveryResults
+{
+    private array $attributeResults = [];
+    private array $interfaceImplementations = [];
+    private array $routes = [];
+    private array $templates = [];
+    private array $additionalResults = [];
+
+    public function __construct(
+        array $attributeResults = [],
+        array $interfaceImplementations = [],
+        array $routes = [],
+        array $templates = [],
+        array $additionalResults = []
+    ) {
+        $this->attributeResults = $attributeResults;
+        $this->interfaceImplementations = $interfaceImplementations;
+        $this->routes = $routes;
+        $this->templates = $templates;
+        $this->additionalResults = $additionalResults;
+    }
+
+    // === Attribute Results ===
+
+    public function setAttributeResults(array $results): void
+    {
+        $this->attributeResults = $results;
+    }
+
+    public function addAttributeResult(string $attributeClass, array $data): void
+    {
+        $this->attributeResults[$attributeClass][] = $data;
+    }
+
+    public function getAttributeResults(string $attributeClass): array
+    {
+        return $this->attributeResults[$attributeClass] ?? [];
+    }
+
+    public function getAllAttributeResults(): array
+    {
+        return $this->attributeResults;
+    }
+
+    public function hasAttributeResults(string $attributeClass): bool
+    {
+        return !empty($this->attributeResults[$attributeClass]);
+    }
+
+    // === Interface Implementations ===
+
+    public function setInterfaceImplementations(array $implementations): void
+    {
+        $this->interfaceImplementations = $implementations;
+    }
+
+    public function addInterfaceImplementation(string $interface, string $className): void
+    {
+        if (!isset($this->interfaceImplementations[$interface])) {
+            $this->interfaceImplementations[$interface] = [];
+        }
+
+        if (!in_array($className, $this->interfaceImplementations[$interface])) {
+            $this->interfaceImplementations[$interface][] = $className;
+        }
+    }
+
+    public function getInterfaceImplementations(string $interface): array
+    {
+        return $this->interfaceImplementations[$interface] ?? [];
+    }
+
+    public function getAllInterfaceImplementations(): array
+    {
+        return $this->interfaceImplementations;
+    }
+
+    // === Routes ===
+
+    public function setRoutes(array $routes): void
+    {
+        $this->routes = $routes;
+    }
+
+    public function getRoutes(): array
+    {
+        return $this->routes;
+    }
+
+    // === Templates ===
+
+    public function setTemplates(array $templates): void
+    {
+        $this->templates = $templates;
+    }
+
+    public function getTemplates(): array
+    {
+        return $this->templates;
+    }
+
+    // === Additional Results ===
+
+    public function setAdditionalResult(string $key, mixed $value): void
+    {
+        $this->additionalResults[$key] = $value;
+    }
+
+    public function getAdditionalResult(string $key, mixed $default = null): mixed
+    {
+        return $this->additionalResults[$key] ?? $default;
+    }
+
+    public function has(string $key): bool
+    {
+        return isset($this->additionalResults[$key]) ||
+            isset($this->attributeResults[$key]) ||
+            isset($this->interfaceImplementations[$key]) ||
+            isset($this->routes[$key]) ||
+            isset($this->templates[$key]);
+    }
+
+    // === Compatibility with old ProcessedResults ===
+
+    /**
+     * Kompatibilitätsmethode für bestehenden Code
+     */
+    public function get(string $key): array
+    {
+        // Direkte Suche nach dem Key
+        if (isset($this->attributeResults[$key])) {
+            return $this->attributeResults[$key];
+        }
+
+        // Versuche auch mit führendem Backslash
+        $keyWithBackslash = '\\' . ltrim($key, '\\');
+        if (isset($this->attributeResults[$keyWithBackslash])) {
+            return $this->attributeResults[$keyWithBackslash];
+        }
+
+        // Versuche ohne führenden Backslash
+        $keyWithoutBackslash = ltrim($key, '\\');
+        if (isset($this->attributeResults[$keyWithoutBackslash])) {
+            return $this->attributeResults[$keyWithoutBackslash];
+        }
+
+        // Für Interfaces (z.B. Initializer::class)
+        if (isset($this->interfaceImplementations[$key])) {
+            return array_map(function($className) {
+                return ['class' => $className];
+            }, $this->interfaceImplementations[$key]);
+        }
+
+        if (isset($this->interfaceImplementations[$keyWithBackslash])) {
+            return array_map(function($className) {
+                return ['class' => $className];
+            }, $this->interfaceImplementations[$keyWithBackslash]);
+        }
+
+        if (isset($this->interfaceImplementations[$keyWithoutBackslash])) {
+            return array_map(function($className) {
+                return ['class' => $className];
+            }, $this->interfaceImplementations[$keyWithoutBackslash]);
+        }
+
+        // Für spezielle Keys
+        switch ($key) {
+            case 'routes':
+                return $this->routes;
+            case 'templates':
+                return $this->templates;
+        }
+
+        return $this->additionalResults[$key] ?? [];
+    }
+
+    // === Serialization ===
+
+    public function toArray(): array
+    {
+        return [
+            'attributes' => $this->attributeResults,
+            'interfaces' => $this->interfaceImplementations,
+            'routes' => $this->routes,
+            'templates' => $this->templates,
+            'additional' => $this->additionalResults,
+        ];
+    }
+
+    public static function fromArray(array $data): self
+    {
+        return new self(
+            $data['attributes'] ?? [],
+            $data['interfaces'] ?? [],
+            $data['routes'] ?? [],
+            $data['templates'] ?? [],
+            $data['additional'] ?? []
+        );
+    }
+
+/*    public function __serialize(): array
+    {
+        return $this->toArray();
+    }
+
+    public function __unserialize(array $data): void
+    {
+        $this->attributeResults = $data['attributes'] ?? [];
+        $this->interfaceImplementations = $data['interfaces'] ?? [];
+        $this->routes = $data['routes'] ?? [];
+        $this->templates = $data['templates'] ?? [];
+        $this->additionalResults = $data['additional'] ?? [];
+    }*/
+
+    // === Utility Methods ===
+
+    public function isEmpty(): bool
+    {
+        return empty($this->attributeResults)
+            && empty($this->interfaceImplementations)
+            && empty($this->routes)
+            && empty($this->templates)
+            && empty($this->additionalResults);
+    }
+
+    public function merge(DiscoveryResults $other): self
+    {
+        return new self(
+            array_merge_recursive($this->attributeResults, $other->attributeResults),
+            array_merge_recursive($this->interfaceImplementations, $other->interfaceImplementations),
+            array_merge($this->routes, $other->routes),
+            array_merge($this->templates, $other->templates),
+            array_merge($this->additionalResults, $other->additionalResults)
+        );
+    }
+
+    /**
+     * Sortiert Interface-Implementierungen für konsistente Ergebnisse
+     */
+    public function sortInterfaceImplementations(): void
+    {
+        foreach ($this->interfaceImplementations as &$implementations) {
+            sort($implementations);
+            $implementations = array_unique($implementations);
+        }
+    }
+}
diff --git a/src/Framework/Discovery/UnifiedDiscoveryService.php b/src/Framework/Discovery/UnifiedDiscoveryService.php
new file mode 100644
index 00000000..f84f71dd
--- /dev/null
+++ b/src/Framework/Discovery/UnifiedDiscoveryService.php
@@ -0,0 +1,168 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Discovery;
+
+use App\Framework\Cache\Cache;
+use App\Framework\Core\InterfaceImplementationVisitor;
+use App\Framework\Core\PathProvider;
+use App\Framework\Core\RouteDiscoveryVisitor;
+use App\Framework\Discovery\Results\DiscoveryResults;
+use App\Framework\Discovery\Visitors\AttributeDiscoveryVisitor;
+use App\Framework\View\TemplateDiscoveryVisitor;
+
+/**
+ * Einheitlicher Discovery-Service der alle Visitor koordiniert
+ * Eliminiert doppelte Dateisystem-Iteration durch einmaligen Scan
+ */
+final readonly class UnifiedDiscoveryService
+{
+    private FileScannerService $fileScannerService;
+
+    public function __construct(
+        private PathProvider $pathProvider,
+        private Cache $cache,
+        private array $attributeMappers = [],
+        private array $targetInterfaces = [],
+        private bool $useCache = true,
+        private bool $showProgress = false
+    ) {
+        // FileScannerService mit den richtigen Abhängigkeiten initialisieren
+        $this->fileScannerService = new FileScannerService(
+            new FileScanner(),
+            $pathProvider,
+            $cache,
+            $this->useCache
+        );
+    }
+
+    /**
+     * Führt die einheitliche Discovery durch
+     * Ein einziger Scan für alle Discovery-Typen
+     */
+    public function discover(): DiscoveryResults
+    {
+        $cacheKey = 'unified_discovery_results';
+
+        // Prüfe Cache nur wenn aktiviert
+        if ($this->useCache) {
+            $cached = $this->cache->get($cacheKey);
+            if ($cached->isHit) {
+                return DiscoveryResults::fromArray($cached->value);
+            }
+        }
+
+        // Registriere alle Visitors
+        $this->registerVisitors();
+
+        // Ein einziger Scan für alle Discovery-Typen
+        $this->fileScannerService->scan($this->showProgress);
+
+        // Sammle Ergebnisse von allen Visitors
+        $results = $this->collectResults();
+
+
+        // Cache für nächsten Aufruf speichern
+        if ($this->useCache) {
+            $this->cache->set($cacheKey, $results->toArray());
+        }
+
+        return $results;
+    }
+
+    /**
+     * Führt einen inkrementellen Scan durch
+     */
+    public function incrementalDiscover(): DiscoveryResults
+    {
+        // Registriere alle Visitors
+        $this->registerVisitors();
+
+        // Inkrementeller Scan
+        $this->fileScannerService->incrementalScan($this->showProgress);
+
+        // Sammle aktualisierte Ergebnisse
+        $results = $this->collectResults();
+
+        // Cache aktualisieren
+        if ($this->useCache) {
+            $this->cache->set('unified_discovery_results', $results->toArray());
+        }
+
+        return $results;
+    }
+
+    /**
+     * Registriert alle benötigten Visitors
+     */
+    private function registerVisitors(): void
+    {
+        // Attribute Discovery Visitor
+        if (!empty($this->attributeMappers)) {
+            $this->fileScannerService->registerVisitor(
+                new AttributeDiscoveryVisitor($this->attributeMappers)
+            );
+        }
+
+        // Interface Implementation Visitor
+        if (!empty($this->targetInterfaces)) {
+            $this->fileScannerService->registerVisitor(
+                new InterfaceImplementationVisitor($this->targetInterfaces)
+            );
+        }
+
+        // Route Discovery Visitor
+        $this->fileScannerService->registerVisitor(
+            new RouteDiscoveryVisitor()
+        );
+
+        // Template Discovery Visitor
+        $this->fileScannerService->registerVisitor(
+            new TemplateDiscoveryVisitor()
+        );
+
+        // Hier können weitere Visitors hinzugefügt werden
+    }
+
+    /**
+     * Sammelt Ergebnisse von allen registrierten Visitors
+     */
+    private function collectResults(): DiscoveryResults
+    {
+        $results = new DiscoveryResults();
+
+        foreach ($this->fileScannerService->getVisitors() as $visitor) {
+            if ($visitor instanceof AttributeDiscoveryVisitor) {
+                $results->setAttributeResults($visitor->getAllResults());
+            } elseif ($visitor instanceof InterfaceImplementationVisitor) {
+                $results->setInterfaceImplementations($visitor->getAllImplementations());
+            } elseif ($visitor instanceof RouteDiscoveryVisitor) {
+                $results->setRoutes($visitor->getRoutes());
+            } elseif ($visitor instanceof TemplateDiscoveryVisitor) {
+                $results->setTemplates($visitor->getAllTemplates());
+            }
+        }
+
+        // Sortiere Interface-Implementierungen für konsistente Ergebnisse
+        $results->sortInterfaceImplementations();
+
+        return $results;
+    }
+
+
+    /**
+     * Gibt die Anzahl der verarbeiteten Dateien zurück
+     */
+    public function getProcessedFileCount(): int
+    {
+        return $this->fileScannerService->getProcessedFileCount() ?? 0;
+    }
+
+    /**
+     * Prüft, ob ein Rescan notwendig ist
+     */
+    public function shouldRescan(): bool
+    {
+        return $this->fileScannerService->shouldRescan();
+    }
+}
diff --git a/src/Framework/Discovery/Visitors/AttributeDiscoveryVisitor.php b/src/Framework/Discovery/Visitors/AttributeDiscoveryVisitor.php
new file mode 100644
index 00000000..fb919cc9
--- /dev/null
+++ b/src/Framework/Discovery/Visitors/AttributeDiscoveryVisitor.php
@@ -0,0 +1,323 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Discovery\Visitors;
+
+use AllowDynamicProperties;
+use App\Framework\Cache\Cache;
+use App\Framework\Core\AttributeMapper;
+use App\Framework\Discovery\FileVisitor;
+use Attribute;
+use Override;
+use ReflectionClass;
+use ReflectionMethod;
+use ReturnTypeWillChange;
+use SensitiveParameter;
+use Throwable;
+
+final class AttributeDiscoveryVisitor implements FileVisitor
+{
+    private array $attributeResults = [];
+
+    /** @var array<string, AttributeMapper> */
+    private array $mapperMap;
+
+    /**
+     * @param array<AttributeMapper|string> $attributeMappers Array von Mapper-Instanzen oder Klassennamen
+     */
+    /** @var array<string> PHP-interne Attribute die ignoriert werden sollen */
+    private array $ignoredAttributes = [
+        'Attribute',
+        Attribute::class,
+        'Override',
+        Override::class,
+        'AllowDynamicProperties',
+        AllowDynamicProperties::class,
+        'ReturnTypeWillChange',
+        ReturnTypeWillChange::class,
+        'SensitiveParameter',
+        SensitiveParameter::class,
+    ];
+
+    public function __construct(array $attributeMappers = [])
+    {
+        $this->mapperMap = [];
+        foreach ($attributeMappers as $mapper) {
+            if (is_string($mapper)) {
+                $mapper = new $mapper();
+            }
+            $this->mapperMap[$mapper->getAttributeClass()] = $mapper;
+        }
+    }
+
+    public function onScanStart(): void
+    {
+        $this->attributeResults = [];
+    }
+
+    public function onIncrementalScanStart(): void
+    {
+        // Bei inkrementellem Scan behalten wir bestehende Attribute
+        // Einzelne Klassen werden bei visitClass() aktualisiert
+    }
+
+    public function onIncrementalScanComplete(): void
+    {
+        // Eventuell nachsortieren oder optimieren
+        $this->optimizeResults();
+    }
+
+    public function visitClass(string $className, string $filePath): void
+    {
+        if (!class_exists($className)) {
+            return;
+        }
+
+        try {
+            $reflection = new ReflectionClass($className);
+
+            // Entferne alte Einträge für diese Klasse (wichtig für inkrementelle Scans)
+            $this->removeAttributesForClass($className);
+
+            // Klassen-Attribute verarbeiten
+            $this->processElementAttributes($reflection);
+
+            // Methoden-Attribute verarbeiten
+            foreach ($reflection->getMethods(ReflectionMethod::IS_PUBLIC) as $method) {
+                $this->processElementAttributes($method);
+            }
+        } catch (Throwable $e) {
+            error_log("Fehler beim Verarbeiten der Attribute für {$className}: " . $e->getMessage());
+        }
+    }
+
+    /**
+     * Verarbeitet die Attribute eines Elements (Klasse oder Methode)
+     */
+    private function processElementAttributes(ReflectionClass|ReflectionMethod $element): void
+    {
+        foreach ($element->getAttributes() as $attribute) {
+
+            $attrName = $attribute->getName();
+
+            // Ignoriere PHP-interne Attribute
+            if ($this->shouldIgnoreAttribute($attrName)) {
+                continue;
+            }
+
+            $attributeInstance = $attribute->newInstance();
+
+            // Standard-Daten für alle Attribute sammeln
+            $baseData = [
+                'attribute_class' => $attrName,
+                'target_type' => $element instanceof ReflectionClass ? 'class' : 'method',
+                'class' => $element instanceof ReflectionClass ? $element->getName() : $element->getDeclaringClass()->getName(),
+                'file' => $element instanceof ReflectionClass ? $element->getFileName() : $element->getDeclaringClass()->getFileName(),
+            ];
+
+            if ($element instanceof ReflectionMethod) {
+                $baseData['method'] = $element->getName();
+                $baseData['parameters'] = $this->extractMethodParameters($element);
+            }
+
+            // Attribute-spezifische Daten hinzufügen
+            $baseData['attribute_data'] = $this->extractAttributeData($attributeInstance);
+
+            // Wenn ein Mapper existiert, verwende ihn
+            if (isset($this->mapperMap[$attrName])) {
+                $mapped = $this->mapperMap[$attrName]->map($element, $attributeInstance);
+
+                if ($mapped !== null) {
+                    // Füge Parameter-Informationen hinzu bei Methoden (falls noch nicht vom Mapper gemacht)
+                    if ($element instanceof ReflectionMethod && !isset($mapped['parameters'])) {
+                        $mapped['parameters'] = $this->extractMethodParameters($element);
+                    }
+
+                    $this->attributeResults[$attrName][] = $mapped;
+                }
+            } else {
+                // Keine Mapper vorhanden - verwende Standard-Daten
+                #debug("Attribute ohne Mapper gefunden: $attrName");
+                $this->attributeResults[$attrName][] = $baseData;
+            }
+        }
+    }
+
+    /**
+     * Extrahiert Parameter-Informationen aus einer Methode
+     */
+    private function extractMethodParameters(ReflectionMethod $method): array
+    {
+        $params = [];
+        foreach ($method->getParameters() as $param) {
+            $paramData = [
+                'name' => $param->getName(),
+                'type' => $param->getType()?->getName(),
+                'isBuiltin' => $param->getType()?->isBuiltin() ?? false,
+                'hasDefault' => $param->isDefaultValueAvailable(),
+                'default' => $param->isDefaultValueAvailable() ? $param->getDefaultValue() : null,
+                'attributes' => array_map(
+                    fn ($a) => $a->getName(),
+                    $param->getAttributes()
+                ),
+            ];
+            $params[] = $paramData;
+        }
+
+        return $params;
+    }
+
+    /**
+     * Prüft, ob ein Attribut ignoriert werden soll
+     */
+    private function shouldIgnoreAttribute(string $attributeName): bool
+    {
+        // Direkte Prüfung
+        if (in_array($attributeName, $this->ignoredAttributes, true)) {
+            return true;
+        }
+
+        // Prüfung ohne Namespace (falls nur Klassenname verwendet wird)
+        $shortName = substr($attributeName, strrpos($attributeName, '\\') + 1);
+        if (in_array($shortName, $this->ignoredAttributes, true)) {
+            return true;
+        }
+
+        return false;
+    }
+
+    /**
+     * Extrahiert verfügbare Daten aus einem Attribute-Objekt
+     */
+    private function extractAttributeData(object $attributeInstance): array
+    {
+        $data = [];
+
+        try {
+            $reflection = new ReflectionClass($attributeInstance);
+
+            // Öffentliche Eigenschaften
+            foreach ($reflection->getProperties() as $property) {
+                if ($property->isPublic()) {
+                    $data[$property->getName()] = $property->getValue($attributeInstance);
+                }
+            }
+
+            // Constructor-Parameter (für readonly properties)
+            $constructor = $reflection->getConstructor();
+            if ($constructor) {
+                foreach ($constructor->getParameters() as $param) {
+                    $name = $param->getName();
+                    if (!isset($data[$name])) {
+                        // Versuche über magische Methoden oder Getter
+                        $getter = 'get' . ucfirst($name);
+                        if (method_exists($attributeInstance, $getter)) {
+                            $data[$name] = $attributeInstance->$getter();
+                        } elseif (property_exists($attributeInstance, $name)) {
+                            $property = $reflection->getProperty($name);
+                            if ($property->isPublic() ||
+                                ($property->isProtected() || $property->isPrivate()) &&
+                                version_compare(PHP_VERSION, '8.1.0') >= 0) {
+                                try {
+                                    $data[$name] = $property->getValue($attributeInstance);
+                                } catch (Throwable) {
+                                    // Ignore protected/private properties we can't access
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        } catch (Throwable $e) {
+            error_log("Fehler beim Extrahieren der Attribute-Daten: " . $e->getMessage());
+        }
+
+        return $data;
+    }
+
+    /**
+     * Entfernt alle Attribute für eine bestimmte Klasse (für inkrementelle Scans)
+     */
+    private function removeAttributesForClass(string $className): void
+    {
+        foreach ($this->attributeResults as $attributeClass => &$results) {
+            $results = array_filter($results, function($result) use ($className) {
+                return ($result['class'] ?? '') !== $className;
+            });
+            // Array-Indizes neu numerieren
+            $results = array_values($results);
+        }
+    }
+
+    /**
+     * Optimiert die Ergebnisse für bessere Performance
+     */
+    private function optimizeResults(): void
+    {
+        foreach ($this->attributeResults as &$results) {
+            // Sortiere nach Klasse und Methode für konsistente Reihenfolge
+            usort($results, function($a, $b) {
+                $classCompare = ($a['class'] ?? '') <=> ($b['class'] ?? '');
+                if ($classCompare !== 0) {
+                    return $classCompare;
+                }
+                return ($a['method'] ?? '') <=> ($b['method'] ?? '');
+            });
+        }
+    }
+
+    public function onScanComplete(): void
+    {
+        $this->optimizeResults();
+    }
+
+    public function loadFromCache(Cache $cache): void
+    {
+        $cacheItem = $cache->get($this->getCacheKey());
+        if ($cacheItem->isHit) {
+            $this->attributeResults = $cacheItem->value ?? [];
+        }
+    }
+
+    public function getCacheKey(): string
+    {
+        return 'attribute_discovery';
+    }
+
+    public function getCacheableData(): mixed
+    {
+        return $this->attributeResults;
+    }
+
+    /**
+     * Gibt alle Attribute-Ergebnisse für eine bestimmte Attributklasse zurück
+     */
+    public function getAttributeResults(string $attributeClass): array
+    {
+        return $this->attributeResults[$attributeClass] ?? [];
+    }
+
+    /**
+     * Gibt alle gefundenen Attribute-Ergebnisse zurück
+     */
+    public function getAllResults(): array
+    {
+        return $this->attributeResults;
+    }
+
+    /**
+     * Prüft, ob Attribute einer bestimmten Klasse gefunden wurden
+     */
+    public function hasAttributeResults(string $attributeClass): bool
+    {
+        return !empty($this->attributeResults[$attributeClass]);
+    }
+
+    /**
+     * Gibt die Anzahl gefundener Attribute zurück
+     */
+    public function getAttributeCount(string $attributeClass): int
+    {
+        return count($this->attributeResults[$attributeClass] ?? []);
+    }
+}
diff --git a/src/Framework/ErrorHandling/CliErrorHandler.php b/src/Framework/ErrorHandling/CliErrorHandler.php
new file mode 100644
index 00000000..1eeb0c7d
--- /dev/null
+++ b/src/Framework/ErrorHandling/CliErrorHandler.php
@@ -0,0 +1,99 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\ErrorHandling;
+
+use App\Framework\Console\ConsoleColor;
+use App\Framework\Console\ConsoleOutput;
+
+/**
+ * CLI-spezifischer Error Handler für Worker und Console
+ */
+final readonly class CliErrorHandler
+{
+    public function __construct(
+        private ?ConsoleOutput $output = null
+    ) {}
+
+    public function register(): void
+    {
+        set_error_handler([$this, 'handleError']);
+        set_exception_handler([$this, 'handleException']);
+        register_shutdown_function([$this, 'handleShutdown']);
+    }
+
+    public function handleError(int $severity, string $message, string $file, int $line): bool
+    {
+        if (!(error_reporting() & $severity)) {
+            return false;
+        }
+
+        $errorType = $this->getErrorType($severity);
+        $color = $this->getErrorColor($severity);
+
+        $output = $this->output ?? new ConsoleOutput();
+        $output->writeLine("[$errorType] $message", $color);
+        $output->writeLine("  in $file:$line", ConsoleColor::GRAY);
+
+        if (in_array($severity, [E_ERROR, E_CORE_ERROR, E_COMPILE_ERROR, E_USER_ERROR])) {
+            exit(1);
+        }
+
+        return true;
+    }
+
+    public function handleException(\Throwable $exception): void
+    {
+        $output = $this->output ?? new ConsoleOutput();
+
+        $output->writeLine("❌ Uncaught " . get_class($exception) . ": " . $exception->getMessage(), ConsoleColor::BRIGHT_RED);
+        $output->writeLine("   File: " . $exception->getFile() . ":" . $exception->getLine(), ConsoleColor::RED);
+
+        if ($exception->getPrevious()) {
+            $output->writeLine("   Caused by: " . $exception->getPrevious()->getMessage(), ConsoleColor::YELLOW);
+        }
+
+        $output->writeLine("   Stack trace:", ConsoleColor::GRAY);
+        foreach (explode("\n", $exception->getTraceAsString()) as $line) {
+            $output->writeLine("     " . $line, ConsoleColor::GRAY);
+        }
+
+        exit(1);
+    }
+
+    public function handleShutdown(): void
+    {
+        $error = error_get_last();
+
+        if ($error && in_array($error['type'], [E_ERROR, E_PARSE, E_CORE_ERROR, E_COMPILE_ERROR])) {
+            $output = $this->output ?? new ConsoleOutput();
+            $output->writeLine("💥 Fatal Error: " . $error['message'], ConsoleColor::BRIGHT_RED);
+            $output->writeLine("   File: " . $error['file'] . ":" . $error['line'], ConsoleColor::RED);
+        }
+    }
+
+    private function getErrorType(int $severity): string
+    {
+        return match ($severity) {
+            E_ERROR, E_CORE_ERROR, E_COMPILE_ERROR, E_USER_ERROR => 'ERROR',
+            E_WARNING, E_CORE_WARNING, E_COMPILE_WARNING, E_USER_WARNING => 'WARNING',
+            E_NOTICE, E_USER_NOTICE => 'NOTICE',
+            E_STRICT => 'STRICT',
+            E_RECOVERABLE_ERROR => 'RECOVERABLE_ERROR',
+            E_DEPRECATED, E_USER_DEPRECATED => 'DEPRECATED',
+            default => 'UNKNOWN'
+        };
+    }
+
+    private function getErrorColor(int $severity): ConsoleColor
+    {
+        return match ($severity) {
+            E_ERROR, E_CORE_ERROR, E_COMPILE_ERROR, E_USER_ERROR => ConsoleColor::BRIGHT_RED,
+            E_WARNING, E_CORE_WARNING, E_COMPILE_WARNING, E_USER_WARNING => ConsoleColor::YELLOW,
+            E_NOTICE, E_USER_NOTICE => ConsoleColor::CYAN,
+            E_DEPRECATED, E_USER_DEPRECATED => ConsoleColor::MAGENTA,
+            default => ConsoleColor::WHITE
+        };
+    }
+}
diff --git a/src/Framework/ErrorHandling/DummyTemplateRenderer.php b/src/Framework/ErrorHandling/DummyTemplateRenderer.php
new file mode 100644
index 00000000..3842dc36
--- /dev/null
+++ b/src/Framework/ErrorHandling/DummyTemplateRenderer.php
@@ -0,0 +1,21 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\ErrorHandling;
+
+use App\Framework\View\RenderContext;
+use App\Framework\View\TemplateRenderer;
+
+/**
+ * Dummy-Implementierung des TemplateRenderer als Fallback
+ */
+final class DummyTemplateRenderer implements TemplateRenderer
+{
+    public function render(RenderContext $context): string
+    {
+        // Dieser Renderer gibt immer einen leeren String zurück,
+        // da er nur als Fallback dient und der ErrorTemplateRenderer
+        // seine eigene Fallback-Methode hat
+        return '';
+    }
+}
diff --git a/src/Framework/ErrorHandling/ErrorContext.php b/src/Framework/ErrorHandling/ErrorContext.php
new file mode 100644
index 00000000..1e9879c7
--- /dev/null
+++ b/src/Framework/ErrorHandling/ErrorContext.php
@@ -0,0 +1,46 @@
+<?php
+
+namespace App\Framework\ErrorHandling;
+
+use App\Framework\Http\RequestId;
+
+final readonly class ErrorContext
+{
+    public StackTrace $stackTrace;
+
+    public function __construct(
+        public \Throwable $exception,
+        public ErrorLevel $level,
+        public RequestId  $requestId,
+        public array      $additionalData = []
+    )
+    {
+        $this->stackTrace = new StackTrace($exception);
+    }
+
+    /**
+     * Gibt eine HTML-formatierte Version der Fehlermeldung zurück
+     */
+    public function getFormattedMessage(): string
+    {
+        return nl2br(htmlspecialchars($this->exception->getMessage(), ENT_QUOTES, 'UTF-8'));
+    }
+
+    /**
+     * Gibt die Fehlerklasse zurück (ohne Namespace)
+     */
+    public function getErrorClass(): string
+    {
+        $class = get_class($this->exception);
+        $parts = explode('\\', $class);
+        return end($parts);
+    }
+
+    /**
+     * Gibt den vollständigen Klassennamen zurück
+     */
+    public function getFullErrorClass(): string
+    {
+        return get_class($this->exception);
+    }
+}
diff --git a/src/Framework/ErrorHandling/ErrorHandler.php b/src/Framework/ErrorHandling/ErrorHandler.php
index e3018204..6b5c452e 100644
--- a/src/Framework/ErrorHandling/ErrorHandler.php
+++ b/src/Framework/ErrorHandling/ErrorHandler.php
@@ -2,62 +2,200 @@
 
 namespace App\Framework\ErrorHandling;
 
-use App\Framework\Http\Headers;
+use App\Framework\DI\Container;
+use App\Framework\ErrorHandling\View\ApiErrorRenderer;
+use App\Framework\ErrorHandling\View\ErrorResponseFactory;
+use App\Framework\ErrorHandling\View\ErrorTemplateRenderer;
+use App\Framework\Exception\SecurityException;
+use App\Framework\Exception\SecurityLogLevel;
 use App\Framework\Http\HttpResponse;
+use App\Framework\Http\MiddlewareContext;
+use App\Framework\Http\RequestIdGenerator;
 use App\Framework\Http\ResponseEmitter;
-use App\Framework\Http\Status;
-use JetBrains\PhpStorm\NoReturn;
+use App\Framework\Logging\Logger;
+use App\Framework\View\TemplateRenderer;
 use Throwable;
 
-final class ErrorHandler
+final readonly class ErrorHandler
 {
-    public static function register(ResponseEmitter $emitter): void
-    {
-        set_exception_handler(function (Throwable $exception) use ($emitter) {
-            self::handleException($exception, $emitter);
-        });
+    private ErrorLogger $logger;
+    private SecurityEventHandler $securityHandler;
+    private bool $isDebugMode;
 
-        set_error_handler(function (int $errno, string $errstr, string $errfile, int $errline) use ($emitter) {
-            $exception = new \ErrorException($errstr, 0, $errno, $errfile, $errline);
-            self::handleException($exception, $emitter);
-        });
-
-        register_shutdown_function(function () use ($emitter) {
-            $error = error_get_last();
-            if ($error) {
-                $exception = new \ErrorException(
-                    $error['message'],
-                    0,
-                    $error['type'],
-                    $error['file'],
-                    $error['line']
-                );
-                self::handleException($exception, $emitter);
-            }
-        });
+    public function __construct(
+        private ResponseEmitter    $emitter,
+        private Container          $container,
+        private RequestIdGenerator $requestIdGenerator,
+        ?Logger                    $logger = null,
+        ?bool                      $isDebugMode = null,
+        ?SecurityEventHandler      $securityHandler = null
+    ){
+        $this->isDebugMode = $isDebugMode ?? (bool)($_ENV['APP_DEBUG'] ?? false);
+        $this->logger = new ErrorLogger($logger);
+        $this->securityHandler = $securityHandler ?? SecurityEventHandler::createDefault($logger);
     }
 
-    #[NoReturn]
-    private static function handleException(Throwable $e, ResponseEmitter $emitter): void
+    public function register(): void
     {
-        $isDebug = $_ENV['APP_DEBUG'] ?? false;
+        set_exception_handler($this->handleException(...));
+        set_error_handler($this->handleError(...));;
+        register_shutdown_function($this->handleShutdown(...));;
+    }
 
-        $status = Status::INTERNAL_SERVER_ERROR ?? 500;
-        $message = $isDebug
-            ? sprintf("Fehler: %s in %s:%d\n\n%s", $e->getMessage(), $e->getFile(), $e->getLine(), $e->getTraceAsString())
-            : "Es ist ein interner Fehler aufgetreten.";
+    public function createHttpResponse(\Throwable $e, ?MiddlewareContext $context = null): HttpResponse
+    {
+        $errorContext = $this->createErrorContext($e, $context);
 
-        $headers = new Headers()->with('Content-Type', 'text/plain; charset=utf-8');
+        // Standard Error Logging
+        $this->logger->logError($errorContext);
 
-        $response = new HttpResponse(
-            status: $status,
-            headers: $headers,
-            body: $message
+        // Security Event Logging delegieren
+        $this->securityHandler->handleIfSecurityException($e, $context);
+
+        $responseFactory = $this->createResponseFactory();
+
+        $isApiRequest = $responseFactory->isApiRequest();
+
+        return $responseFactory->createResponse(
+            $errorContext,
+            $this->isDebugMode,
+            $isApiRequest
         );
+    }
 
-        // Sende die Fehlermeldung (so früh wie möglich!)
-        $emitter->emit($response);
+    public function handleException(Throwable $e): never
+    {
+        $context = $this->createErrorContext($e);
 
+        // Logge den Fehler
+        $this->logger->logError($context);
+
+        // Security Event Logging delegieren
+        $this->securityHandler->handleIfSecurityException($e);
+
+        // Erstelle ResponseFactory mit dem TemplateRenderer
+        $responseFactory = $this->createResponseFactory();
+
+        // Bestimme ob es ein API-Request ist
+        $isApiRequest = $responseFactory->isApiRequest();
+
+        // Erstelle eine Response basierend auf dem Kontext
+        $response = $responseFactory->createResponse($context, $this->isDebugMode, $isApiRequest);
+
+        // Sende die Fehlermeldung
+        $this->emitter->emit($response);
         exit(1);
     }
+
+    public function handleError(int $errno, string $errstr, string $errfile, int $errline): void
+    {
+        $exception = new \ErrorException($errstr, 0, $errno, $errfile, $errline);
+        $this->handleException($exception);
+    }
+
+    public function handleShutdown(): void
+    {
+        $error = error_get_last();
+        if ($error && $this->isFatalError($error['type'])) {
+            $exception = new \ErrorException(
+                $error['message'],
+                0,
+                $error['type'],
+                $error['file'],
+                $error['line']
+            );
+            $this->handleException($exception);
+        }
+    }
+
+    private function isFatalError(int $errno): bool
+    {
+        return in_array($errno, [E_ERROR, E_PARSE, E_CORE_ERROR, E_COMPILE_ERROR, E_USER_ERROR, E_RECOVERABLE_ERROR], true);
+    }
+
+    private function createErrorContext(Throwable $exception, ?MiddlewareContext $context = null):ErrorContext
+    {
+        $level = $this->determineErrorLevel($exception);
+
+        $requestId = $context->requestId ?? $this->requestIdGenerator->generate();
+
+        return new ErrorContext(
+            exception: $exception,
+            level: $level,
+            requestId: $requestId,
+            additionalData: [
+                'timestamp' => date('c'),
+                'memory_usage' => memory_get_peak_usage(true),
+            ]
+        );
+    }
+
+    private function determineErrorLevel(Throwable $exception):ErrorLevel
+    {
+        return match(true) {
+            $exception instanceof \Error => ErrorLevel::CRITICAL,
+            $exception instanceof \ErrorException => $this->determineErrorExceptionLevel($exception),
+            $exception instanceof SecurityException => $this->determineSecurityErrorLevel($exception),
+            $exception instanceof \RuntimeException => ErrorLevel::ERROR,
+            $exception instanceof \LogicException => ErrorLevel::WARNING,
+            default => ErrorLevel::ERROR,
+        };
+    }
+
+    /**
+     * Bestimmt den Error-Level für SecurityExceptions basierend auf dem Security-Level
+     */
+    private function determineSecurityErrorLevel(SecurityException $exception): ErrorLevel
+    {
+        return match($exception->getSecurityLevel()) {
+            SecurityLogLevel::DEBUG => ErrorLevel::DEBUG,
+            SecurityLogLevel::INFO => ErrorLevel::INFO,
+            SecurityLogLevel::WARN => ErrorLevel::WARNING,
+            SecurityLogLevel::ERROR => ErrorLevel::ERROR,
+            SecurityLogLevel::FATAL => ErrorLevel::CRITICAL,
+        };
+    }
+
+
+    /**
+     * Bestimmt den Fehler-Level basierend auf dem ErrorException-Severity-Level
+     */
+    private function determineErrorExceptionLevel(\ErrorException $exception): ErrorLevel
+    {
+        return match($exception->getSeverity()) {
+            E_ERROR, E_CORE_ERROR, E_COMPILE_ERROR, E_USER_ERROR, E_RECOVERABLE_ERROR => ErrorLevel::CRITICAL,
+            E_WARNING, E_CORE_WARNING, E_COMPILE_WARNING, E_USER_WARNING => ErrorLevel::WARNING,
+            E_NOTICE, E_USER_NOTICE => ErrorLevel::NOTICE,
+            E_DEPRECATED, E_USER_DEPRECATED => ErrorLevel::INFO,
+            E_STRICT => ErrorLevel::DEBUG,
+            default => ErrorLevel::ERROR,
+        };
+    }
+
+    /**
+     * Erstellt eine ErrorResponseFactory mit Renderern
+     * Versucht den TemplateRenderer aus dem Container zu laden, falls vorhanden
+     */
+    private function createResponseFactory(): ErrorResponseFactory
+    {
+        $templateRenderer = null;
+
+        // Versuche TemplateRenderer aus Container zu laden
+        if ($this->container && $this->container->has(TemplateRenderer::class)) {
+            try {
+                $templateRenderer = $this->container->get(TemplateRenderer::class);
+            } catch (Throwable $e) {
+                // Falls ein Fehler beim Laden auftritt, verwende Fallback
+                $templateRenderer = null;
+            }
+        }
+
+        $htmlRenderer = $templateRenderer ?
+            new ErrorTemplateRenderer($templateRenderer) :
+            new ErrorTemplateRenderer(new DummyTemplateRenderer());
+
+        $apiRenderer = new ApiErrorRenderer();
+
+        return new ErrorResponseFactory($htmlRenderer, $apiRenderer);
+    }
 }
diff --git a/src/Framework/ErrorHandling/ErrorLevel.php b/src/Framework/ErrorHandling/ErrorLevel.php
new file mode 100644
index 00000000..0344502c
--- /dev/null
+++ b/src/Framework/ErrorHandling/ErrorLevel.php
@@ -0,0 +1,13 @@
+<?php
+
+namespace App\Framework\ErrorHandling;
+
+enum ErrorLevel
+{
+    case CRITICAL;
+    case ERROR;
+    case WARNING;
+    case NOTICE;
+    case INFO;
+    case DEBUG;
+}
diff --git a/src/Framework/ErrorHandling/ErrorLogger.php b/src/Framework/ErrorHandling/ErrorLogger.php
new file mode 100644
index 00000000..d80cc1ff
--- /dev/null
+++ b/src/Framework/ErrorHandling/ErrorLogger.php
@@ -0,0 +1,88 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\ErrorHandling;
+
+use App\Framework\Logging\Logger;
+use App\Framework\Logging\LogLevel;
+
+/**
+ * Logger für Fehler und Exceptions - nutzt Framework Logger
+ */
+final readonly class ErrorLogger
+{
+    public function __construct(
+        private ?Logger $logger = null
+    ) {}
+
+    /**
+     * Loggt einen Fehler basierend auf dem ErrorContext
+     */
+    public function logError(ErrorContext $context): void
+    {
+        $exception = $context->exception;
+        $message = sprintf(
+            '[%s] %s: %s in %s:%d',
+            $context->requestId,
+            get_class($exception),
+            $exception->getMessage(),
+            $exception->getFile(),
+            $exception->getLine()
+        );
+
+        $contextData = [
+            'exception' => $exception,
+            'trace' => $exception->getTraceAsString(),
+            'requestId' => $context->requestId,
+            'additionalData' => $context->additionalData
+        ];
+
+        if ($this->logger !== null) {
+            $logLevel = $this->mapErrorLevelToFrameworkLevel($context->level);
+            $this->logger->log($logLevel, $message, $contextData);
+        } else {
+            // Fallback auf error_log
+            $this->logToErrorLog($context);
+        }
+    }
+
+
+    /**
+     * Fallback-Methode für Logging ohne Framework Logger
+     */
+    private function logToErrorLog(ErrorContext $context): void
+    {
+        $exception = $context->exception;
+        $message = sprintf(
+            '[%s] [%s] %s: %s in %s:%d',
+            date('Y-m-d H:i:s'),
+            $context->level->name,
+            get_class($exception),
+            $exception->getMessage(),
+            $exception->getFile(),
+            $exception->getLine()
+        );
+
+        error_log($message);
+
+        // Bei kritischen Fehlern auch den Stacktrace loggen
+        if ($context->level === ErrorLevel::CRITICAL) {
+            error_log("Stack trace: \n" . $exception->getTraceAsString());
+        }
+    }
+
+    /**
+     * Mappt interne ErrorLevel auf Framework LogLevel
+     */
+    private function mapErrorLevelToFrameworkLevel(ErrorLevel $level): LogLevel
+    {
+        return match($level) {
+            ErrorLevel::CRITICAL => LogLevel::CRITICAL,
+            ErrorLevel::ERROR => LogLevel::ERROR,
+            ErrorLevel::WARNING => LogLevel::WARNING,
+            ErrorLevel::NOTICE => LogLevel::NOTICE,
+            ErrorLevel::INFO => LogLevel::INFO,
+            ErrorLevel::DEBUG => LogLevel::DEBUG,
+        };
+    }
+}
diff --git a/src/Framework/ErrorHandling/ExceptionConverter.php b/src/Framework/ErrorHandling/ExceptionConverter.php
new file mode 100644
index 00000000..f082cd37
--- /dev/null
+++ b/src/Framework/ErrorHandling/ExceptionConverter.php
@@ -0,0 +1,75 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\ErrorHandling;
+
+use App\Framework\Http\Status;
+
+/**
+ * Hilfsklasse zur Konvertierung von Exceptions in HTTP-Status-Codes.
+ */
+final class ExceptionConverter
+{
+    /**
+     * Bestimmt den HTTP-Status basierend auf dem Exception-Typ
+     */
+    public static function getStatusFromException(\Throwable $e): Status
+    {
+        return match (true) {
+            // Routing-Fehler
+            $e instanceof \App\Framework\Router\Exception\RouteNotFound => Status::NOT_FOUND,
+            $e instanceof \App\Framework\Router\Exception\MethodNotAllowed => Status::METHOD_NOT_ALLOWED,
+
+            // Validierungs-Fehler
+            $e instanceof \App\Framework\Validation\Exceptions\ValidationException => Status::BAD_REQUEST,
+
+            // API-Fehler
+            $e instanceof \App\Framework\Api\ApiException => Status::BAD_GATEWAY,
+
+            // Datenbank-Fehler
+            $e instanceof \PDOException => Status::INTERNAL_SERVER_ERROR,
+
+            // Standard
+            default => Status::INTERNAL_SERVER_ERROR,
+        };
+    }
+
+    /**
+     * Erstellt den Response-Body basierend auf der Exception
+     */
+    public static function getResponseBody(\Throwable $e, bool $debug = false, ?string $requestId = null): array
+    {
+        if ($debug) {
+            // Im Debug-Modus detaillierte Informationen zurückgeben
+            return [
+                'error' => true,
+                'message' => $e->getMessage(),
+                'file' => $e->getFile(),
+                'line' => $e->getLine(),
+                'trace' => explode("\n", $e->getTraceAsString()),
+                'request_id' => $requestId,
+            ];
+        }
+
+        // Im Produktionsmodus nur minimale Informationen
+        return [
+            'error' => true,
+            'message' => self::getUserFriendlyMessage($e),
+            'request_id' => $requestId,
+        ];
+    }
+
+    /**
+     * Gibt eine benutzerfreundliche Fehlermeldung basierend auf dem Exception-Typ zurück
+     */
+    public static function getUserFriendlyMessage(\Throwable $e): string
+    {
+        return match (true) {
+            $e instanceof \App\Framework\Router\Exception\RouteNotFound => 'Die angeforderte Seite wurde nicht gefunden.',
+            $e instanceof \App\Framework\Router\Exception\MethodNotAllowed => 'Diese Anfragemethode ist nicht erlaubt.',
+            $e instanceof \App\Framework\Validation\Exceptions\ValidationException => 'Die eingegebenen Daten sind ungültig.',
+            $e instanceof \App\Framework\Api\ApiException => 'Es ist ein Fehler bei der Kommunikation mit einem externen Dienst aufgetreten.',
+            default => 'Es ist ein interner Fehler aufgetreten.',
+        };
+    }
+}
diff --git a/src/Framework/ErrorHandling/SecurityAlertManager.php b/src/Framework/ErrorHandling/SecurityAlertManager.php
new file mode 100644
index 00000000..ddbe414e
--- /dev/null
+++ b/src/Framework/ErrorHandling/SecurityAlertManager.php
@@ -0,0 +1,88 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\ErrorHandling;
+
+use App\Framework\Exception\SecurityException;
+use App\Framework\Exception\ErrorHandlerContext;
+
+/**
+ * Manager für Security-Alerts - Integration zu externen Alert-Systemen
+ */
+final readonly class SecurityAlertManager
+{
+    public function __construct(
+        private array $alertChannels = []
+    ) {}
+
+    /**
+     * Sendet Alert über alle konfigurierten Kanäle
+     */
+    public function sendAlert(
+        SecurityException $exception,
+        ErrorHandlerContext $context
+    ): void {
+        $alertData = $this->createAlertPayload($exception, $context);
+
+        foreach ($this->alertChannels as $channel) {
+            try {
+                $channel->sendAlert($alertData);
+            } catch (\Throwable $e) {
+                // Alert-Fehler nicht propagieren, nur loggen
+                error_log("Alert channel failed: " . $e->getMessage());
+            }
+        }
+    }
+
+    /**
+     * Erstellt standardisierte Alert-Payload
+     */
+    private function createAlertPayload(
+        SecurityException $exception,
+        ErrorHandlerContext $context
+    ): array {
+        $securityEvent = $exception->getSecurityEvent();
+
+        return [
+            'type' => 'security_alert',
+            'severity' => $this->mapSeverity($exception->getSecurityLevel()),
+            'event_id' => $securityEvent->getEventIdentifier(),
+            'title' => 'Security Event: ' . $securityEvent->getCategory(),
+            'description' => $securityEvent->getDescription(),
+            'details' => [
+                'category' => $securityEvent->getCategory(),
+                'level' => $exception->getSecurityLevel()->value,
+                'client_ip' => $context->request->clientIp,
+                'user_agent' => $context->request->userAgent,
+                'request_uri' => $context->request->requestUri,
+                'timestamp' => date('c'),
+                'request_id' => $context->request->requestId
+            ],
+            'event_data' => $securityEvent->toArray(),
+            'context' => $context->forLogging()
+        ];
+    }
+
+    /**
+     * Mappt Security-Level auf Alert-Severity
+     */
+    private function mapSeverity(\App\Framework\Exception\SecurityLogLevel $level): string
+    {
+        return match($level) {
+            \App\Framework\Exception\SecurityLogLevel::FATAL => 'critical',
+            \App\Framework\Exception\SecurityLogLevel::ERROR => 'high',
+            \App\Framework\Exception\SecurityLogLevel::WARN => 'medium',
+            \App\Framework\Exception\SecurityLogLevel::INFO => 'low',
+            \App\Framework\Exception\SecurityLogLevel::DEBUG => 'info',
+        };
+    }
+
+    /**
+     * Factory mit Standard-Alert-Kanälen
+     */
+    public static function createWithChannels(array $channels): self
+    {
+        return new self($channels);
+    }
+}
diff --git a/src/Framework/ErrorHandling/SecurityEventHandler.php b/src/Framework/ErrorHandling/SecurityEventHandler.php
new file mode 100644
index 00000000..9351924a
--- /dev/null
+++ b/src/Framework/ErrorHandling/SecurityEventHandler.php
@@ -0,0 +1,123 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\ErrorHandling;
+
+use App\Framework\Exception\SecurityException;
+use App\Framework\Exception\ErrorHandlerContext;
+use App\Framework\Http\MiddlewareContext;
+use App\Framework\Logging\Logger;
+use Throwable;
+
+/**
+ * Spezialisierte Klasse für Security-Event-Handling und OWASP-konformes Logging
+ */
+final readonly class SecurityEventHandler
+{
+    public function __construct(
+        private SecurityEventLogger $securityLogger,
+        private ?SecurityAlertManager $alertManager = null
+    ) {}
+
+    /**
+     * Behandelt Security-Exception und führt entsprechendes Logging durch
+     */
+    public function handleSecurityException(
+        SecurityException $exception,
+        ?MiddlewareContext $context = null
+    ): void {
+        try {
+            // Erstelle ErrorHandlerContext für OWASP-Format
+            $errorHandlerContext = ErrorHandlerContext::fromException($exception, $context);
+
+            // Führe Security-Logging durch
+            $this->securityLogger->logSecurityEvent($exception, $errorHandlerContext);
+
+            // Sende Alert falls erforderlich
+            if ($exception->requiresAlert()) {
+                $this->handleSecurityAlert($exception, $errorHandlerContext);
+            }
+
+        } catch (Throwable $loggingError) {
+            // Fallback-Logging: Niemals Security-Events verlieren
+            $this->handleLoggingFailure($exception, $loggingError);
+        }
+    }
+
+    /**
+     * Prüft ob Exception eine SecurityException ist und behandelt sie entsprechend
+     */
+    public function handleIfSecurityException(
+        Throwable $exception,
+        ?MiddlewareContext $context = null
+    ): bool {
+        if (!$exception instanceof SecurityException) {
+            return false;
+        }
+
+        $this->handleSecurityException($exception, $context);
+        return true;
+    }
+
+    /**
+     * Behandelt Security-Alerts
+     */
+    private function handleSecurityAlert(
+        SecurityException $exception,
+        ErrorHandlerContext $context
+    ): void {
+        if ($this->alertManager) {
+            $this->alertManager->sendAlert($exception, $context);
+        } else {
+            // Fallback: Logge als kritisches Event
+            $this->securityLogger->logCriticalAlert($exception, $context);
+        }
+    }
+
+    /**
+     * Behandelt Fehler beim Security-Logging (Fallback)
+     */
+    private function handleLoggingFailure(
+        SecurityException $originalException,
+        Throwable $loggingError
+    ): void {
+        // Niemals Security-Events verlieren - verwende error_log als Fallback
+        $fallbackMessage = sprintf(
+            'SECURITY_AUDIT_FAILURE: Failed to log security event %s - %s',
+            $originalException->getSecurityEvent()->getEventIdentifier(),
+            $loggingError->getMessage()
+        );
+
+        error_log($fallbackMessage);
+
+        // Versuche minimales Security-Log
+        try {
+            $minimalLog = [
+                'datetime' => date('c'),
+                'event' => $originalException->getSecurityEvent()->getEventIdentifier(),
+                'description' => $originalException->getSecurityEvent()->getDescription(),
+                'level' => 'FATAL',
+                'audit_failure' => true,
+                'original_error' => $loggingError->getMessage()
+            ];
+
+            error_log('SECURITY_EVENT_FALLBACK: ' . json_encode($minimalLog));
+
+        } catch (Throwable $criticalError) {
+            // Absoluter Fallback
+            error_log('CRITICAL_SECURITY_AUDIT_FAILURE: Unable to log security event');
+        }
+    }
+
+    /**
+     * Factory-Methode mit Standard-Konfiguration
+     */
+    public static function createDefault(?Logger $logger = null): self
+    {
+        $securityLogger = new SecurityEventLogger($logger);
+        $alertManager = null; // Kann später konfiguriert werden
+
+        return new self($securityLogger, $alertManager);
+    }
+}
diff --git a/src/Framework/ErrorHandling/SecurityEventLogger.php b/src/Framework/ErrorHandling/SecurityEventLogger.php
new file mode 100644
index 00000000..3ac27593
--- /dev/null
+++ b/src/Framework/ErrorHandling/SecurityEventLogger.php
@@ -0,0 +1,163 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\ErrorHandling;
+
+use App\Framework\Exception\SecurityException;
+use App\Framework\Exception\ErrorHandlerContext;
+use App\Framework\Exception\SecurityLogLevel;
+use App\Framework\Logging\Logger;
+use App\Framework\Logging\LogLevel;
+
+/**
+ * Spezialisierter Logger für Security-Events im OWASP-Format
+ */
+final readonly class SecurityEventLogger
+{
+    public function __construct(
+        private ?Logger $logger = null,
+        private string $applicationId = 'app'
+    ) {}
+
+    /**
+     * Loggt Security-Event im OWASP-Format
+     */
+    public function logSecurityEvent(
+        SecurityException $exception,
+        ErrorHandlerContext $context
+    ): void {
+        $securityEvent = $exception->getSecurityEvent();
+
+        // OWASP-konformes Log generieren
+        $owaspLog = $this->createOWASPLog($exception, $context);
+
+        if ($this->logger) {
+            // Strukturiertes Logging über Framework Logger
+            $frameworkLogLevel = $this->mapSecurityLevelToFrameworkLevel($securityEvent->getLogLevel());
+
+            $this->logger->log(
+                $frameworkLogLevel,
+                $securityEvent->getDescription(),
+                [
+                    'security_event' => $securityEvent->getEventIdentifier(),
+                    'security_category' => $securityEvent->getCategory(),
+                    'requires_alert' => $securityEvent->requiresAlert(),
+                    'owasp_format' => $owaspLog,
+                    'event_data' => $securityEvent->toArray(),
+                    'context_data' => $context->forLogging()
+                ]
+            );
+        } else {
+            // Fallback auf error_log
+            $this->logToErrorLog($owaspLog);
+        }
+    }
+
+    /**
+     * Loggt kritische Security-Alerts
+     */
+    public function logCriticalAlert(
+        SecurityException $exception,
+        ErrorHandlerContext $context
+    ): void {
+        $alertData = $this->createAlertData($exception, $context);
+
+        if ($this->logger) {
+            $this->logger->log(
+                LogLevel::CRITICAL,
+                'SECURITY_ALERT: ' . $exception->getSecurityEvent()->getEventIdentifier(),
+                $alertData
+            );
+        } else {
+            error_log('SECURITY_ALERT: ' . json_encode($alertData));
+        }
+    }
+
+    /**
+     * Erstellt OWASP-konformes Log-Format
+     */
+    private function createOWASPLog(
+        SecurityException $exception,
+        ErrorHandlerContext $context
+    ): array {
+        $securityEvent = $exception->getSecurityEvent();
+
+        return [
+            'datetime' => date('c'),
+            'appid' => $this->applicationId,
+            'event' => $securityEvent->getEventIdentifier(),
+            'level' => $securityEvent->getLogLevel()->value,
+            'description' => $securityEvent->getDescription(),
+            'useragent' => $context->request->userAgent,
+            'source_ip' => $context->request->clientIp,
+            'host_ip' => $context->request->hostIp,
+            'hostname' => $context->request->hostname,
+            'protocol' => $context->request->protocol,
+            'port' => $context->request->port,
+            'request_uri' => $context->request->requestUri,
+            'request_method' => $context->request->requestMethod,
+            'region' => $_ENV['AWS_REGION'] ?? 'unknown',
+            'geo' => $_ENV['GEO_LOCATION'] ?? 'unknown',
+            'category' => $securityEvent->getCategory(),
+            'requires_alert' => $securityEvent->requiresAlert()
+        ];
+    }
+
+    /**
+     * Erstellt Alert-Daten für kritische Events
+     */
+    private function createAlertData(
+        SecurityException $exception,
+        ErrorHandlerContext $context
+    ): array {
+        return [
+            'event' => $exception->getSecurityEvent()->getEventIdentifier(),
+            'description' => $exception->getSecurityEvent()->getDescription(),
+            'level' => $exception->getSecurityLevel()->value,
+            'category' => $exception->getSecurityEvent()->getCategory(),
+            'client_ip' => $context->request->clientIp,
+            'user_agent' => $context->request->userAgent,
+            'request_uri' => $context->request->requestUri,
+            'request_method' => $context->request->requestMethod,
+            'timestamp' => date('c'),
+            'request_id' => $context->request->requestId,
+            'event_data' => $exception->getSecurityEvent()->toArray()
+        ];
+    }
+
+    /**
+     * Fallback-Logging über error_log
+     */
+    private function logToErrorLog(array $owaspLog): void
+    {
+        $logMessage = 'SECURITY_EVENT: ' . json_encode($owaspLog, JSON_UNESCAPED_SLASHES);
+        error_log($logMessage);
+    }
+
+    /**
+     * Mappt SecurityLogLevel auf Framework LogLevel
+     */
+    private function mapSecurityLevelToFrameworkLevel(
+        SecurityLogLevel $securityLevel
+    ): LogLevel {
+        return match($securityLevel) {
+            SecurityLogLevel::DEBUG => LogLevel::DEBUG,
+            SecurityLogLevel::INFO => LogLevel::INFO,
+            SecurityLogLevel::WARN => LogLevel::WARNING,
+            SecurityLogLevel::ERROR => LogLevel::ERROR,
+            SecurityLogLevel::FATAL => LogLevel::CRITICAL,
+        };
+    }
+
+    /**
+     * Factory-Methode für Standard-Konfiguration
+     */
+    public static function create(?Logger $logger = null): self
+    {
+        return new self(
+            $logger,
+            $_ENV['APP_NAME'] ?? $_ENV['APP_ID'] ?? 'app'
+        );
+    }
+}
diff --git a/src/Framework/ErrorHandling/StackTrace.php b/src/Framework/ErrorHandling/StackTrace.php
new file mode 100644
index 00000000..3ef07859
--- /dev/null
+++ b/src/Framework/ErrorHandling/StackTrace.php
@@ -0,0 +1,152 @@
+<?php
+
+namespace App\Framework\ErrorHandling;
+
+use ArrayAccess;
+use Countable;
+use IteratorAggregate;
+use ArrayIterator;
+use Traversable;
+
+/**
+ * Stacktrace-Klasse zum Aufbereiten und Darstellen von Exception-Traces
+ * Implementiert ArrayAccess, IteratorAggregate und Countable für einfachen Zugriff in Templates
+ */
+final class StackTrace implements ArrayAccess, IteratorAggregate, Countable
+{
+    /** @var TraceItem[] */
+    private(set) array $items = [];
+
+    /**
+     * Erstellt ein neues StackTrace-Objekt aus einer Exception
+     */
+    public function __construct(private readonly \Throwable $exception)
+    {
+        $this->processTrace($exception->getTrace());
+    }
+
+    /**
+     * Verarbeitet die rohen Trace-Daten in strukturierte TraceItems
+     */
+    private function processTrace(array $trace): void
+    {
+        // Füge den Ursprung der Exception hinzu (file/line aus Exception selbst)
+        $this->items[] = new TraceItem(
+            file: $this->exception->getFile(),
+            line: $this->exception->getLine(),
+            function: null,
+            class: null,
+            type: null,
+            args: [],
+            isExceptionOrigin: true
+        );
+
+        // Verarbeite den Rest des Stacktraces
+        foreach ($trace as $index => $frame) {
+            $this->items[] = new TraceItem(
+                file: $frame['file'] ?? '(internal function)',
+                line: $frame['line'] ?? 0,
+                function: $frame['function'] ?? null,
+                class: $frame['class'] ?? null,
+                type: $frame['type'] ?? null,
+                args: $frame['args'] ?? [],
+                isExceptionOrigin: false
+            );
+        }
+
+        $this->items = array_reverse($this->items);
+    }
+
+    /**
+     * Gibt alle Trace-Items zurück
+     *
+     * @return TraceItem[]
+     */
+    public function getItems(): array
+    {
+        return $this->items;
+    }
+
+    /**
+     * Gibt den Ursprung der Exception zurück (erstes Item)
+     */
+    public function getOrigin(): ?TraceItem
+    {
+        return $this->items[0] ?? null;
+    }
+
+    /**
+     * Gibt die ersten N Elemente des Stacktraces zurück
+     */
+    public function getFirst(int $count): array
+    {
+        return array_slice($this->items, 0, $count);
+    }
+
+    /**
+     * Gibt die letzten N Elemente des Stacktraces zurück
+     */
+    public function getLast(int $count): array
+    {
+        return array_slice($this->items, -$count);
+    }
+
+    /**
+     * Filtert den Stacktrace nach bestimmten Kriterien
+     */
+    public function filter(callable $callback): array
+    {
+        return array_filter($this->items, $callback);
+    }
+
+    /**
+     * Implementierung von ArrayAccess
+     */
+    public function offsetExists(mixed $offset): bool
+    {
+        return isset($this->items[$offset]);
+    }
+
+    public function offsetGet(mixed $offset): mixed
+    {
+        return $this->items[$offset] ?? null;
+    }
+
+    public function offsetSet(mixed $offset, mixed $value): void
+    {
+        // Read-only
+    }
+
+    public function offsetUnset(mixed $offset): void
+    {
+        // Read-only
+    }
+
+    /**
+     * Implementierung von IteratorAggregate
+     */
+    public function getIterator(): Traversable
+    {
+        return new ArrayIterator($this->items);
+    }
+
+    /**
+     * Implementierung von Countable
+     */
+    public function count(): int
+    {
+        return count($this->items);
+    }
+
+    /**
+     * Formatiert den gesamten Stacktrace als String
+     */
+    public function __toString(): string
+    {
+        $result = "";
+        foreach ($this->items as $index => $item) {
+            $result .= "#{$index} {$item}\n";
+        }
+        return $result;
+    }
+}
diff --git a/src/Framework/ErrorHandling/TraceItem.php b/src/Framework/ErrorHandling/TraceItem.php
new file mode 100644
index 00000000..0275d8fd
--- /dev/null
+++ b/src/Framework/ErrorHandling/TraceItem.php
@@ -0,0 +1,144 @@
+<?php
+
+namespace App\Framework\ErrorHandling;
+
+/**
+ * Repräsentiert einen einzelnen Eintrag im Stacktrace
+ */
+final readonly class TraceItem
+{
+    public function __construct(
+        public string $file,
+        public int $line,
+        public ?string $function,
+        public ?string $class,
+        public ?string $type,
+        public array $args,
+        public bool $isExceptionOrigin
+    ) {}
+
+    /**
+     * Gibt den Dateipfad relativ zum Projekt-Root zurück
+     */
+    public function getRelativeFile(bool $namespace = true): string
+    {
+        $projectRoot = dirname(__DIR__, 3); // Annahme: 3 Verzeichnisse zurück zum Projekt-Root
+        $name = str_replace($projectRoot, '', $this->file);
+
+        return $namespace ? $name : $this->removeNamespace($name);
+    }
+
+    /**
+     * Gibt den Klassennamen ohne Namespace zurück
+     */
+    public function getShortClass(): ?string
+    {
+        if (!$this->class) {
+            return null;
+        }
+
+        $parts = explode('\\', $this->class);
+        return end($parts);
+    }
+
+    /**
+     * Gibt den Namespace zurück
+     */
+    public function getNamespace(): ?string
+    {
+        if (!$this->class) {
+            return null;
+        }
+
+        $lastSlash = strrpos($this->class, '\\');
+        return $lastSlash ? substr($this->class, 0, $lastSlash) : null;
+    }
+
+    /**
+     * Gibt zurück, ob es sich um einen Methodenaufruf handelt
+     */
+    public function isMethod(): bool
+    {
+        return $this->class !== null && $this->function !== null;
+    }
+
+    /**
+     * Gibt zurück, ob es sich um einen Funktionsaufruf handelt
+     */
+    public function isFunction(): bool
+    {
+        return $this->class === null && $this->function !== null;
+    }
+
+    /**
+     * Gibt den Aufruf-String zurück (z.B. "Namespace\Class->method()")
+     */
+    public function getCallString(): string
+    {
+        if ($this->isExceptionOrigin) {
+            return "Exception origin: >>" . $this->file . '<< in Line: ' . $this->line;
+        }
+
+        if ($this->isMethod()) {
+            return $this->getShortClass() . $this->type . $this->function . '(' . $this->formatArgs() . ')';
+        }
+
+        if ($this->isFunction()) {
+            return $this->function . '(' . $this->formatArgs() . ')';
+        }
+
+        return '';
+    }
+
+    /**
+     * Formatiert die Argumente für die Anzeige
+     */
+    private function formatArgs(): string
+    {
+        if (empty($this->args)) {
+            return '';
+        }
+
+        $formatted = [];
+
+        foreach ($this->args as $arg) {
+            $formatted[] = $this->formatArg($arg);
+        }
+
+        return implode(', ', $formatted);
+    }
+
+    /**
+     * Formatiert ein einzelnes Argument für die Anzeige
+     */
+    private function formatArg(mixed $arg): string
+    {
+        return match(true) {
+            is_string($arg) => '"' . (strlen($arg) > 20 ? substr($arg, 0, 20) . '...' : $arg) . '"',
+            is_array($arg) => 'array(' . count($arg) . ')',
+            is_object($arg) => $this->removeNamespace(get_class($arg)),
+            is_bool($arg) => $arg ? 'true' : 'false',
+            is_null($arg) => 'null',
+            default => (string)$arg
+        };
+    }
+
+    private function removeNamespace(string $class): string
+    {
+        $lastSlash = strrpos($class, '\\');
+        return $lastSlash ? substr($class, $lastSlash + 1) : $class;
+    }
+
+    /**
+     * String-Repräsentation dieses TraceItems
+     */
+    public function __toString(): string
+    {
+        $locationInfo = $this->file . ':' . $this->line;
+        if ($this->isExceptionOrigin) {
+            return "Exception origin: {$locationInfo}";
+        }
+
+        return $this->getCallString() . " at {$locationInfo}";
+    }
+}
diff --git a/src/Framework/ErrorHandling/View/ApiErrorRenderer.php b/src/Framework/ErrorHandling/View/ApiErrorRenderer.php
new file mode 100644
index 00000000..c68cb8e8
--- /dev/null
+++ b/src/Framework/ErrorHandling/View/ApiErrorRenderer.php
@@ -0,0 +1,39 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\ErrorHandling\View;
+
+use App\Framework\ErrorHandling\ErrorContext;
+use App\Framework\ErrorHandling\ExceptionConverter;
+
+/**
+ * Renderer für API-Fehler im JSON-Format
+ */
+final readonly class ApiErrorRenderer implements ErrorViewRendererInterface
+{
+    /**
+     * Rendert einen API-Fehler als JSON
+     */
+    public function render(ErrorContext $context, bool $isDebug = false): string
+    {
+        $responseData = [
+            'error' => true,
+            'message' => $isDebug ? $context->exception->getMessage() : ExceptionConverter::getUserFriendlyMessage($context->exception),
+            'requestId' => $context->requestId,
+            'timestamp' => $context->additionalData['timestamp'] ?? date('c'),
+        ];
+
+        // Im Debug-Modus zusätzliche Informationen hinzufügen
+        if ($isDebug) {
+            $responseData['details'] = [
+                'exception' => get_class($context->exception),
+                'file' => $context->exception->getFile(),
+                'line' => $context->exception->getLine(),
+                'trace' => explode("\n", $context->exception->getTraceAsString()),
+                'level' => $context->level->name,
+            ];
+        }
+
+        return json_encode($responseData, JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES);
+    }
+}
diff --git a/src/Framework/ErrorHandling/View/ErrorResponseFactory.php b/src/Framework/ErrorHandling/View/ErrorResponseFactory.php
new file mode 100644
index 00000000..d359c4c8
--- /dev/null
+++ b/src/Framework/ErrorHandling/View/ErrorResponseFactory.php
@@ -0,0 +1,79 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\ErrorHandling\View;
+
+use App\Framework\ErrorHandling\ErrorContext;
+use App\Framework\ErrorHandling\ExceptionConverter;
+use App\Framework\Http\Headers;
+use App\Framework\Http\HttpResponse;
+use App\Framework\Http\Status;
+
+/**
+ * Factory für HTTP-Fehlermeldungen
+ */
+final readonly class ErrorResponseFactory
+{
+    public function __construct(
+        private ErrorViewRendererInterface $htmlRenderer,
+        private ErrorViewRendererInterface $apiRenderer
+    ) {}
+
+    /**
+     * Erstellt eine HTTP-Response basierend auf dem ErrorContext
+     */
+    public function createResponse(ErrorContext $context, bool $isDebug = false, bool $isApiRequest = false): HttpResponse
+    {
+        $status = ExceptionConverter::getStatusFromException($context->exception);
+        $headers = new Headers();
+
+        if ($isApiRequest) {
+            $headers = $headers->with('Content-Type', 'application/json; charset=utf-8');
+            $body = $this->apiRenderer->render($context, $isDebug);
+        } else {
+            $headers = $headers->with('Content-Type', 'text/html; charset=utf-8');
+            $body = $this->htmlRenderer->render($context, $isDebug);
+        }
+
+        // Cache-Control hinzufügen (Fehlerseiten sollten nicht gecacht werden)
+        $headers = $headers->with('Cache-Control', 'no-store, no-cache, must-revalidate');
+
+        return new HttpResponse(
+            status: $status,
+            headers: $headers,
+            body: $body
+        );
+    }
+
+    /**
+     * Bestimmt, ob es sich um eine API-Anfrage handelt
+     */
+    public function isApiRequest(): bool
+    {
+        // Accept-Header prüfen
+        $acceptHeader = $_SERVER['HTTP_ACCEPT'] ?? '';
+        if (str_contains($acceptHeader, 'application/json')) {
+            return true;
+        }
+
+        // URL-Pfad prüfen (z.B. /api/...)
+        $requestUri = $_SERVER['REQUEST_URI'] ?? '';
+        if (str_starts_with($requestUri, '/api/')) {
+            return true;
+        }
+
+        // Content-Type prüfen
+        $contentType = $_SERVER['CONTENT_TYPE'] ?? '';
+        if (str_contains($contentType, 'application/json')) {
+            return true;
+        }
+
+        // X-Requested-With Header prüfen (für AJAX)
+        $requestedWith = $_SERVER['HTTP_X_REQUESTED_WITH'] ?? '';
+        if (strtolower($requestedWith) === 'xmlhttprequest') {
+            return true;
+        }
+
+        return false;
+    }
+}
diff --git a/src/Framework/ErrorHandling/View/ErrorTemplateRenderer.php b/src/Framework/ErrorHandling/View/ErrorTemplateRenderer.php
new file mode 100644
index 00000000..6daa63f8
--- /dev/null
+++ b/src/Framework/ErrorHandling/View/ErrorTemplateRenderer.php
@@ -0,0 +1,156 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\ErrorHandling\View;
+
+use App\Framework\ErrorHandling\ErrorContext;
+use App\Framework\Meta\MetaData;
+use App\Framework\Meta\OpenGraphTypeWebsite;
+use App\Framework\SyntaxHighlighter\FileHighlighter;
+use App\Framework\View\RenderContext;
+use App\Framework\View\TemplateRenderer;
+use Throwable;
+
+/**
+ * Renderer für Fehlerseiten unter Verwendung des View-Systems
+ */
+final readonly class ErrorTemplateRenderer implements ErrorViewRendererInterface
+{
+    public function __construct(
+        private TemplateRenderer $renderer,
+        private string $debugTemplate = 'debug',
+        private string $productionTemplate = 'production'
+    ) {}
+
+    /**
+     * Rendert eine Fehlerseite basierend auf dem ErrorContext
+     */
+    public function render(ErrorContext $context, bool $isDebug = false): string
+    {
+        $template = $isDebug ? $this->debugTemplate : $this->productionTemplate;
+
+        try {
+            // Sichere Datenaufbereitung ohne Closures oder komplexe Objekte
+            $safeData = [
+                'code' => new FileHighlighter()($context->exception->getFile(), $context->exception->getLine() -10, 10),
+                'errorClass' => $context->exception::class,
+                'errorMessage' => $context->exception->getMessage(),
+                'error' => [
+                    'message' => $context->exception->getMessage(),
+                    'file' => $context->exception->getFile(),
+                    'line' => $context->exception->getLine(),
+                    'trace' => $context->exception->getTraceAsString(),
+                    'class' => get_class($context->exception),
+                ],
+                'requestId' => $context->requestId->toString(),
+                'timestamp' => $context->additionalData['timestamp'] ?? date('c'),
+                'level' => $context->level->name,
+                'memory' => $context->additionalData['memory_usage'] ?? 0
+            ];
+
+            $renderContext = new RenderContext(
+                template: $template,
+                metaData: new MetaData('', '', new OpenGraphTypeWebsite),
+                data: $safeData
+            );
+
+            $renderedContent = $this->renderer->render($renderContext);
+
+            if($renderedContent === ""){
+                throw new \Exception("Template Renderer returned empty string");
+            }
+
+            return $renderedContent;
+        } catch (Throwable $e) {
+            // Fallback falls das Template-Rendering fehlschlägt
+            return $this->createFallbackErrorPage($context, $isDebug, $e);
+        }
+    }
+
+    /**
+     * Erstellt eine einfache Fehlerseite als Fallback
+     */
+    private function createFallbackErrorPage(ErrorContext $context, bool $isDebug, ?Throwable $renderException = null): string
+    {
+        $exception = $context->exception;
+
+        if ($isDebug) {
+            $content = sprintf(
+                '<!DOCTYPE html>
+                <html>
+                <head>
+                    <meta charset="UTF-8">
+                    <title>Anwendungsfehler</title>
+                    <style>
+                        body { font-family: sans-serif; line-height: 1.6; color: #333; max-width: 1200px; margin: 0 auto; padding: 20px; }
+                        .error-container { background: #f8f9fa; border: 1px solid #dee2e6; border-radius: 4px; padding: 20px; margin: 20px 0; }
+                        .error-title { color: #dc3545; margin-top: 0; }
+                        .error-meta { background: #e9ecef; padding: 10px; border-radius: 4px; font-size: 0.9em; margin: 10px 0; }
+                        .error-trace { background: #f1f3f5; padding: 15px; border-radius: 4px; overflow-x: auto; font-family: monospace; font-size: 0.9em; }
+                        .error-info { margin-bottom: 20px; }
+                        .request-id { font-family: monospace; color: #6c757d; }
+                        .render-error { margin-top: 30px; padding-top: 20px; border-top: 1px dashed #dee2e6; }
+                    </style>
+                </head>
+                <body>
+                    <div class="error-container">
+                        <h1 class="error-title">Anwendungsfehler: %s</h1>
+
+                        <div class="error-meta">
+                            <strong>Request-ID:</strong> <span class="request-id">%s</span><br>
+                            <strong>Zeit:</strong> %s<br>
+                            <strong>Fehler-Level:</strong> %s
+                        </div>
+
+                        <div class="error-info">
+                            <p><strong>Datei:</strong> %s</p>
+                            <p><strong>Zeile:</strong> %d</p>
+                        </div>
+
+                        <h3>Stack Trace:</h3>
+                        <div class="error-trace">%s</div>
+
+                        %s
+                    </div>
+                </body>
+                </html>',
+                htmlspecialchars($exception->getMessage()),
+                htmlspecialchars($context->requestId->toString()),
+                htmlspecialchars($context->additionalData['timestamp'] ?? date('c')),
+                htmlspecialchars($context->level->name),
+                htmlspecialchars($exception->getFile()),
+                $exception->getLine(),
+                nl2br(htmlspecialchars($exception->getTraceAsString())),
+                $renderException ? '<div class="render-error"><h3>Fehler beim Rendern der Fehlerseite:</h3><p>' .
+                htmlspecialchars($renderException->getMessage()) . '</p></div>' : ''
+            );
+        } else {
+            // Produktions-Fallback mit minimalen Informationen
+            $content = sprintf(
+                '<!DOCTYPE html>
+                <html lang="de">
+                <head>
+                    <meta charset="UTF-8">
+                    <title>Fehler</title>
+                    <style>
+                        body { font-family: sans-serif; line-height: 1.6; color: #333; max-width: 800px; margin: 0 auto; padding: 40px 20px; text-align: center; }
+                        .error-container { background: #f8f9fa; border: 1px solid #dee2e6; border-radius: 4px; padding: 40px 20px; }
+                        .error-title { color: #dc3545; margin-top: 0; }
+                        .request-id { font-family: monospace; color: #6c757d; font-size: 0.8em; margin-top: 30px; }
+                    </style>
+                </head>
+                <body>
+                    <div class="error-container">
+                        <h1 class="error-title">Es ist ein Fehler aufgetreten</h1>
+                        <p>Bitte versuchen Sie es später erneut oder kontaktieren Sie den Support.</p>
+                        <p class="request-id">Request-ID: %s</p>
+                    </div>
+                </body>
+                </html>',
+                htmlspecialchars($context->requestId->toString())
+            );
+        }
+
+        return $content;
+    }
+}
diff --git a/src/Framework/ErrorHandling/View/ErrorViewRendererInterface.php b/src/Framework/ErrorHandling/View/ErrorViewRendererInterface.php
new file mode 100644
index 00000000..90490a91
--- /dev/null
+++ b/src/Framework/ErrorHandling/View/ErrorViewRendererInterface.php
@@ -0,0 +1,17 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\ErrorHandling\View;
+
+use App\Framework\ErrorHandling\ErrorContext;
+
+/**
+ * Interface für alle Renderer von Fehlerseiten
+ */
+interface ErrorViewRendererInterface
+{
+    /**
+     * Rendert eine Fehlerseite basierend auf dem ErrorContext
+     */
+    public function render(ErrorContext $context, bool $isDebug = false): string;
+}
diff --git a/src/Framework/ErrorHandling/templates/debug.view.php b/src/Framework/ErrorHandling/templates/debug.view.php
new file mode 100644
index 00000000..0e086bc1
--- /dev/null
+++ b/src/Framework/ErrorHandling/templates/debug.view.php
@@ -0,0 +1,209 @@
+<!DOCTYPE html>
+<html lang="de">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Fehler: $errorClass</title>
+    <style>
+        :root {
+            --bg-color: #f8f9fa;
+            --text-color: #212529;
+            --border-color: #dee2e6;
+            --error-color: #dc3545;
+            --header-bg: #e9ecef;
+            --code-bg: #f5f5f5;
+            --link-color: #0d6efd;
+        }
+
+        @media (prefers-color-scheme: dark) {
+            :root {
+                --bg-color: #212529;
+                --text-color: #f8f9fa;
+                --border-color: #495057;
+                --error-color: #f8d7da;
+                --header-bg: #343a40;
+                --code-bg: #2b3035;
+                --link-color: #6ea8fe;
+            }
+        }
+
+        body {
+            font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial, sans-serif;
+            line-height: 1.6;
+            color: var(--text-color);
+            background: var(--bg-color);
+            margin: 0;
+            padding: 20px;
+        }
+
+        .container {
+            max-width: 1200px;
+            margin: 0 auto;
+        }
+
+        .error-container {
+            background: white;
+            border-radius: 8px;
+            box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
+            overflow: hidden;
+            margin-bottom: 20px;
+        }
+
+        .error-header {
+            background: var(--header-bg);
+            padding: 15px 20px;
+            border-bottom: 1px solid var(--border-color);
+        }
+
+        .error-title {
+            margin: 0;
+            color: var(--error-color);
+            font-size: 1.5rem;
+        }
+
+        .error-body {
+            padding: 20px;
+        }
+
+        .error-message {
+            font-size: 1.1rem;
+            margin-bottom: 20px;
+            padding: 15px;
+            background: #fff5f5;
+            border-left: 4px solid var(--error-color);
+            border-radius: 4px;
+        }
+
+        .error-meta {
+            display: flex;
+            flex-wrap: wrap;
+            gap: 10px;
+            font-size: 0.9rem;
+            color: #6c757d;
+            margin-bottom: 20px;
+        }
+
+        .error-meta span {
+            background: var(--header-bg);
+            padding: 4px 8px;
+            border-radius: 4px;
+        }
+
+        .trace-container {
+            background: white;
+            border-radius: 8px;
+            box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
+            overflow: hidden;
+        }
+
+        .trace-header {
+            background: var(--header-bg);
+            padding: 5px 10px;
+            border-bottom: 1px solid var(--border-color);
+        }
+
+        .trace-title {
+            margin: 0;
+            font-size: 1.2rem;
+        }
+
+        .trace-body {
+            padding: 0;
+        }
+
+        .trace-item {
+            padding: 2px 4px;
+            border-bottom: 1px solid var(--border-color);
+        }
+
+        .trace-item:last-child {
+            border-bottom: none;
+        }
+
+        .trace-location {
+            font-family: monospace;
+            background: var(--code-bg);
+            padding: 4px 8px;
+            border-radius: 4px;
+            word-break: break-all;
+        }
+
+        .trace-call {
+            margin-top: 5px;
+            font-family: monospace;
+            color: #6c757d;
+            word-break: break-all;
+        }
+
+        .trace-origin {
+            background-color: #fff5f5;
+        }
+
+        code {
+            font-family: monospace;
+            background: var(--code-bg);
+            padding: 2px 4px;
+            border-radius: 3px;
+        }
+
+        @media (prefers-color-scheme: dark) {
+            .error-container, .trace-container {
+                background: #343a40;
+            }
+
+            .error-message {
+                background: #3a2a2a;
+            }
+
+            .trace-origin {
+                background-color: #3a2a2a;
+            }
+        }
+    </style>
+</head>
+<body>
+<div class="container">
+    <div class="error-container">
+        <div class="error-header">
+            <h1 class="error-title">{{ errorClass }}</h1>
+        </div>
+
+        <div class="error-body">
+            <div class="error-message">{{ errorMessage }}</div>
+
+            <div class="error-meta">
+                <span>Request ID: {{ requestId }}</span>
+                <span>Zeit: {{ timestamp }}</span>
+                <span>Level: {{ level }}</span>
+                <span>Speicherverbrauch: {{ format_filesize($memory) }}</span>
+            </div>
+        </div>
+    </div>
+
+    <?php echo "Hallo" ?>
+
+    {{ code }}
+
+    <div class="trace-container">
+        <div class="trace-header">
+            <h2 class="trace-title">Stack Trace</h2>
+        </div>
+
+        <div class="trace-body" style="font-size: 0.8rem;">
+            <for var="item" in="trace">
+                <div class="trace-item {{ item->isExceptionOrigin() }} 'trace-origin' : ''">
+                    <div class="trace-location">
+                        {{ item.getRelativeFile() }} <i>Line {{ item.line }}</i>
+                        <!--#$i $item->getRelativeFile():$item->line-->
+                    </div>
+                    <div class="trace-call" style="font-size: 1.25rem; background-color: #81a5ed; color: black; padding: 0.25em;">
+                        {{ item.getCallString() }}
+                    </div>
+                </div>
+            </for>
+
+        </div>
+    </div>
+</div>
+</body>
+</html>
diff --git a/src/Framework/ErrorHandling/templates/production.view.php b/src/Framework/ErrorHandling/templates/production.view.php
new file mode 100644
index 00000000..51c77099
--- /dev/null
+++ b/src/Framework/ErrorHandling/templates/production.view.php
@@ -0,0 +1,106 @@
+<!DOCTYPE html>
+<html lang="de">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Fehler</title>
+    <style>
+        :root {
+            --bg-color: #f8f9fa;
+            --text-color: #212529;
+            --border-color: #dee2e6;
+            --error-color: #dc3545;
+            --header-bg: #e9ecef;
+        }
+
+        @media (prefers-color-scheme: dark) {
+            :root {
+                --bg-color: #212529;
+                --text-color: #f8f9fa;
+                --border-color: #495057;
+                --error-color: #f8d7da;
+                --header-bg: #343a40;
+            }
+        }
+
+        body {
+            font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial, sans-serif;
+            line-height: 1.6;
+            color: var(--text-color);
+            background: var(--bg-color);
+            margin: 0;
+            padding: 0;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            min-height: 100vh;
+        }
+
+        .container {
+            max-width: 600px;
+            padding: 20px;
+        }
+
+        .error-container {
+            background: white;
+            border-radius: 8px;
+            box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
+            overflow: hidden;
+        }
+
+        .error-header {
+            background: var(--header-bg);
+            padding: 15px 20px;
+            border-bottom: 1px solid var(--border-color);
+        }
+
+        .error-title {
+            margin: 0;
+            color: var(--error-color);
+            font-size: 1.5rem;
+        }
+
+        .error-body {
+            padding: 30px 20px;
+            text-align: center;
+        }
+
+        .error-message {
+            font-size: 1.1rem;
+            margin-bottom: 20px;
+        }
+
+        .error-meta {
+            font-size: 0.9rem;
+            color: #6c757d;
+            margin-top: 20px;
+        }
+
+        @media (prefers-color-scheme: dark) {
+            .error-container {
+                background: #343a40;
+            }
+        }
+    </style>
+</head>
+<body>
+<div class="container">
+    <div class="error-container">
+        <div class="error-header">
+            <h1 class="error-title">Ein Fehler ist aufgetreten</h1>
+        </div>
+
+        <div class="error-body">
+            <div class="error-message">
+                Es tut uns leid, aber es ist ein Fehler aufgetreten.
+                Unser Team wurde benachrichtigt und arbeitet an einer Lösung.
+            </div>
+
+            <div class="error-meta">
+                Request ID: $requestId
+            </div>
+        </div>
+    </div>
+</div>
+</body>
+</html>
diff --git a/src/Framework/EventBus/DefaultEventBus.php b/src/Framework/EventBus/DefaultEventBus.php
new file mode 100644
index 00000000..117c7772
--- /dev/null
+++ b/src/Framework/EventBus/DefaultEventBus.php
@@ -0,0 +1,52 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\EventBus;
+
+use App\Framework\DI\DefaultContainer;
+
+final readonly class DefaultEventBus implements EventBus
+{
+    public function __construct(
+        private array     $eventHandlers,
+        private DefaultContainer $container
+    ) {}
+
+    /**
+     * Dispatcht ein Event an alle registrierten Handler
+     *
+     * @param object $event Das zu dispatchende Event
+     * @return void
+     */
+    public function dispatch(object $event): void {
+        $eventClass = get_class($event);
+
+        error_log('Dispatching Event: ' . $eventClass);
+
+        // Prüfe, ob Handler für diesen Event-Typ registriert sind
+        if (empty($this->eventHandlers) || !isset($this->eventHandlers[$eventClass])) {
+            return;
+        }
+
+        // if Handler is Asynchronos send Event to Job Queue
+
+        // Führe alle Handler für diesen Event-Typ aus
+        foreach ($this->eventHandlers as $handler) {
+            try {
+                $handlerClass = $this->container->get($handler['class']);
+                $method = $handler['method'];
+
+                $handlerClass->$method($event);
+
+                // Stoppe die Propagation, wenn der Handler dies anfordert
+                if (isset($handler['attribute_data']['stopPropagation']) && $handler['attribute_data']['stopPropagation']) {
+                    break;
+                }
+            } catch (\Throwable $e) {
+                // Fehler in Event-Handlern sollten die Anwendung nicht abstürzen lassen
+                // In einer echten Anwendung würde hier ein Logger verwendet
+                error_log('Fehler bei der Ausführung des Event-Handlers: ' . $e->getMessage());
+            }
+        }
+    }
+}
diff --git a/src/Framework/EventBus/EventBus.php b/src/Framework/EventBus/EventBus.php
new file mode 100644
index 00000000..01a7a52d
--- /dev/null
+++ b/src/Framework/EventBus/EventBus.php
@@ -0,0 +1,8 @@
+<?php
+
+namespace App\Framework\EventBus;
+
+interface EventBus
+{
+    public function dispatch(object $event): void;
+}
diff --git a/src/Framework/EventBus/EventBusInitializer.php b/src/Framework/EventBus/EventBusInitializer.php
new file mode 100644
index 00000000..7a159372
--- /dev/null
+++ b/src/Framework/EventBus/EventBusInitializer.php
@@ -0,0 +1,28 @@
+<?php
+
+namespace App\Framework\EventBus;
+
+use App\Framework\DI\Container;
+use App\Framework\DI\Initializer;
+use App\Framework\Discovery\Results\DiscoveryResults;
+
+final readonly class EventBusInitializer
+{
+    public function __construct(
+        private Container        $container,
+        private DiscoveryResults $results
+    ){}
+
+    #[Initializer]
+    public function __invoke(): EventBus
+    {
+        $handlers = $this->results->get(EventHandler::class);
+
+        $eventHandlers = [];
+        foreach ($handlers as $handler) {
+            $eventHandlers[$handler['event_class']] = $handler;
+        }
+
+        return new DefaultEventBus($eventHandlers, $this->container);
+    }
+}
diff --git a/src/Framework/EventBus/EventHandler.php b/src/Framework/EventBus/EventHandler.php
new file mode 100644
index 00000000..77908aaa
--- /dev/null
+++ b/src/Framework/EventBus/EventHandler.php
@@ -0,0 +1,24 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\EventBus;
+
+/**
+ * Attribut, das eine Methode als Event-Handler kennzeichnet.
+ *
+ * Beispiel:
+ * #[EventHandler]
+ * public function handleUserRegistered(UserRegistered $event): void { ... }
+ */
+#[\Attribute(\Attribute::TARGET_METHOD)]
+final readonly class EventHandler
+{
+    /**
+     * @param int|null $priority Priorität des Handlers (höhere Werte werden zuerst ausgeführt)
+     * @param bool $stopPropagation Gibt an, ob die Event-Propagation nach diesem Handler gestoppt werden soll
+     */
+    public function __construct(
+        public ?int $priority = null,
+        public bool $stopPropagation = false
+    ) {}
+}
diff --git a/src/Framework/EventBus/EventHandlerCompiler.php b/src/Framework/EventBus/EventHandlerCompiler.php
new file mode 100644
index 00000000..e1737089
--- /dev/null
+++ b/src/Framework/EventBus/EventHandlerCompiler.php
@@ -0,0 +1,70 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\EventBus;
+
+use App\Framework\Core\AttributeCompiler;
+
+/**
+ * Compiler für Event-Handler
+ */
+final readonly class EventHandlerCompiler implements AttributeCompiler
+{
+    /**
+     * Gibt die Attributklasse zurück, die dieser Compiler verarbeitet
+     */
+    public function getAttributeClass(): string
+    {
+        return QueryHandler::class;
+    }
+
+    /**
+     * Kompiliert die Event-Handler
+     *
+     * @param array $handlers Array mit Attributdaten aus dem Mapper
+     * @return array Kompilierte Event-Handler
+     */
+    public function compile(array $handlers): array
+    {
+        $compiledHandlers = [];
+
+        // Wenn keine Handler vorhanden sind, leeres Array zurückgeben
+        if (empty($handlers)) {
+            return $compiledHandlers;
+        }
+
+        foreach ($handlers as $handler) {
+            $className = $handler['class'] ?? null;
+            $methodName = $handler['method'] ?? null;
+            $eventClass = $handler['event_class'] ?? null;
+            $priority = $handler['attribute_data']['priority'] ?? 0;
+            $stopPropagation = $handler['attribute_data']['stopPropagation'] ?? false;
+
+            // Prüfe, ob alle erforderlichen Daten vorhanden sind
+            if (!$className || !$methodName || !$eventClass) {
+                continue;
+            }
+
+            // Füge den Handler zur Liste der Handler für diesen Event-Typ hinzu
+            if (!isset($compiledHandlers[$eventClass])) {
+                $compiledHandlers[$eventClass] = [];
+            }
+
+            $compiledHandlers[$eventClass][] = [
+                'class' => $className,
+                'method' => $methodName,
+                'priority' => $priority,
+                'stopPropagation' => $stopPropagation
+            ];
+        }
+
+        // Sortiere die Handler nach Priorität für jeden Event-Typ
+        foreach ($compiledHandlers as $eventClass => $eventHandlers) {
+            usort($compiledHandlers[$eventClass], function ($a, $b) {
+                return $b['priority'] <=> $a['priority'];
+            });
+        }
+
+        return $compiledHandlers;
+    }
+}
diff --git a/src/Framework/EventBus/EventHandlerMapper.php b/src/Framework/EventBus/EventHandlerMapper.php
new file mode 100644
index 00000000..394eac9e
--- /dev/null
+++ b/src/Framework/EventBus/EventHandlerMapper.php
@@ -0,0 +1,60 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\EventBus;
+
+use App\Framework\Core\AttributeMapper;
+use ReflectionClass;
+use ReflectionMethod;
+
+/**
+ * Mapper für das EventHandler-Attribut
+ */
+final class EventHandlerMapper implements AttributeMapper
+{
+    /**
+     * Gibt die Attributklasse zurück, die dieser Mapper verarbeitet
+     */
+    public function getAttributeClass(): string
+    {
+        return EventHandler::class;
+    }
+
+    /**
+     * Implementiert die map-Methode aus dem AttributeMapper-Interface
+     *
+     * @param object $reflectionTarget Das Reflektionsobjekt (ReflectionClass|ReflectionMethod)
+     * @param object $attributeInstance Die Attributinstanz
+     * @return array|null Die Attributdaten oder null, wenn nicht verarbeitet werden kann
+     */
+    public function map(object $reflectionTarget, object $attributeInstance): ?array
+    {
+        if (!($reflectionTarget instanceof ReflectionMethod)) {
+            return null;
+        }
+
+        $parameters = $reflectionTarget->getParameters();
+
+        // Event-Handler müssen mindestens einen Parameter haben (das Event)
+        if (count($parameters) < 1) {
+            return null;
+        }
+
+        $eventType = $parameters[0]->getType();
+        if (!$eventType || $eventType->isBuiltin()) {
+            return null;
+        }
+
+        $eventClassName = $eventType->getName();
+
+        return [
+            'class' => $reflectionTarget->getDeclaringClass()->getName(),
+            'method' => $reflectionTarget->getName(),
+            'event_class' => $eventClassName,
+            'attribute_data' => [
+                'priority' => $attributeInstance->priority ?? 0,
+                'stopPropagation' => $attributeInstance->stopPropagation ?? false
+            ],
+        ];
+    }
+}
diff --git a/src/Framework/EventBus/Middleware.php b/src/Framework/EventBus/Middleware.php
new file mode 100644
index 00000000..2b8227dd
--- /dev/null
+++ b/src/Framework/EventBus/Middleware.php
@@ -0,0 +1,8 @@
+<?php
+
+namespace App\Framework\EventBus;
+
+interface Middleware
+{
+    public function handle(object $event, callable $next): void;
+}
diff --git a/src/Framework/Exception/ConsoleException.php b/src/Framework/Exception/ConsoleException.php
new file mode 100644
index 00000000..094c87d8
--- /dev/null
+++ b/src/Framework/Exception/ConsoleException.php
@@ -0,0 +1,43 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Exception;
+
+final class ConsoleException extends FrameworkException
+{
+    public static function commandFailed(string $command, int $exitCode, string $output = ''): self
+    {
+        $context = ExceptionContext::forOperation('console.command', 'ConsoleRunner')
+            ->withData([
+                'command' => $command,
+                'exit_code' => $exitCode,
+                'output' => $output,
+                'working_directory' => getcwd()
+            ]);
+
+        return new self("Console command failed: {$command}", $exitCode, null, $context);
+    }
+
+    public static function commandNotFound(string $command): self
+    {
+        $context = ExceptionContext::forOperation('console.command_lookup', 'ConsoleRunner')
+            ->withData([
+                'command' => $command
+            ]);
+
+        return new self("Console command not found: {$command}", 404, null, $context);
+    }
+
+    public static function invalidArguments(string $command, array $arguments, array $errors): self
+    {
+        $context = ExceptionContext::forOperation('console.argument_validation', 'ConsoleRunner')
+            ->withData([
+                'command' => $command,
+                'arguments' => $arguments,
+                'validation_errors' => $errors
+            ]);
+
+        return new self("Invalid arguments for command: {$command}", 400, null, $context);
+    }
+}
diff --git a/src/Framework/Exception/DatabaseException.php b/src/Framework/Exception/DatabaseException.php
new file mode 100644
index 00000000..f2a7d839
--- /dev/null
+++ b/src/Framework/Exception/DatabaseException.php
@@ -0,0 +1,61 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Exception;
+
+final class DatabaseException extends FrameworkException
+{
+    public static function connectionFailed(string $dsn, \Throwable $previous): self
+    {
+        $context = ExceptionContext::forOperation('database.connect', 'PDO')
+            ->withData([
+                'dsn' => self::sanitizeDsn($dsn),
+                'driver' => explode(':', $dsn)[0] ?? 'unknown'
+            ]);
+
+        return new self('Database connection failed', 0, $previous, $context);
+    }
+
+    public static function queryFailed(string $query, array $params, \Throwable $previous): self
+    {
+        $context = ExceptionContext::forOperation('database.query', 'PDO')
+            ->withData([
+                'query' => $query,
+                'parameters' => $params,
+                'query_type' => self::detectQueryType($query)
+            ]);
+
+        return new self('Database query failed', 0, $previous, $context);
+    }
+
+    public static function transactionFailed(string $operation, \Throwable $previous): self
+    {
+        $context = ExceptionContext::forOperation('database.transaction', 'PDO')
+            ->withData([
+                'transaction_operation' => $operation
+            ]);
+
+        return new self("Database transaction failed: {$operation}", 0, $previous, $context);
+    }
+
+    private static function sanitizeDsn(string $dsn): string
+    {
+        return preg_replace('/password=[^;]+/', 'password=[REDACTED]', $dsn);
+    }
+
+    private static function detectQueryType(string $query): string
+    {
+        $query = trim(strtoupper($query));
+        return match (true) {
+            str_starts_with($query, 'SELECT') => 'SELECT',
+            str_starts_with($query, 'INSERT') => 'INSERT',
+            str_starts_with($query, 'UPDATE') => 'UPDATE',
+            str_starts_with($query, 'DELETE') => 'DELETE',
+            str_starts_with($query, 'CREATE') => 'CREATE',
+            str_starts_with($query, 'DROP') => 'DROP',
+            str_starts_with($query, 'ALTER') => 'ALTER',
+            default => 'UNKNOWN'
+        };
+    }
+}
diff --git a/src/Framework/Exception/DirectoryCreateException.php b/src/Framework/Exception/DirectoryCreateException.php
new file mode 100644
index 00000000..2903b4ac
--- /dev/null
+++ b/src/Framework/Exception/DirectoryCreateException.php
@@ -0,0 +1,30 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Exception;
+
+final class DirectoryCreateException extends FrameworkException
+{
+    public function __construct(
+        string $directory,
+        int $code = 0,
+        ?\Throwable $previous = null
+    ) {
+        $context = ExceptionContext::forOperation('filesystem.create_directory', 'FileSystem')
+            ->withData([
+                'directory' => $directory,
+                'permissions' => is_dir(dirname($directory)) ? decoct(fileperms(dirname($directory))) : 'unknown',
+                'parent_exists' => is_dir(dirname($directory)),
+                'parent_writable' => is_writable(dirname($directory)),
+                'disk_free_space' => disk_free_space(dirname($directory))
+            ]);
+
+        parent::__construct(
+            message: "Ordner '$directory' konnte nicht angelegt werden.",
+            code: $code,
+            previous: $previous,
+            context: $context
+        );
+    }
+}
diff --git a/src/Framework/Exception/DirectoryListException.php b/src/Framework/Exception/DirectoryListException.php
new file mode 100644
index 00000000..6e810c55
--- /dev/null
+++ b/src/Framework/Exception/DirectoryListException.php
@@ -0,0 +1,30 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Exception;
+
+final class DirectoryListException extends FrameworkException
+{
+    public function __construct(
+        string $directory,
+        int $code = 0,
+        ?\Throwable $previous = null
+    ) {
+        $context = ExceptionContext::forOperation('filesystem.list_directory', 'FileSystem')
+            ->withData([
+                'directory' => $directory,
+                'exists' => is_dir($directory),
+                'readable' => is_readable($directory),
+                'permissions' => is_dir($directory) ? decoct(fileperms($directory)) : 'unknown',
+                'file_count' => is_readable($directory) ? count(scandir($directory)) - 2 : 'unknown'
+            ]);
+
+        parent::__construct(
+            message: "Fehler beim Auslesen des Verzeichnisses '$directory'.",
+            code: $code,
+            previous: $previous,
+            context: $context
+        );
+    }
+}
diff --git a/src/Framework/Exception/ErrorHandlerContext.php b/src/Framework/Exception/ErrorHandlerContext.php
new file mode 100644
index 00000000..eabf2efa
--- /dev/null
+++ b/src/Framework/Exception/ErrorHandlerContext.php
@@ -0,0 +1,208 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Exception;
+
+use App\Framework\Http\MiddlewareContext;
+
+/**
+ * Vollständiger Kontext für Error-Handling - kombiniert alle Kontext-Typen
+ */
+final readonly class ErrorHandlerContext
+{
+    public function __construct(
+        public ExceptionContext $exception,
+        public RequestContext $request,
+        public SystemContext $system,
+        public array $metadata = []
+    ) {}
+
+    public static function create(
+        ExceptionContext $exceptionContext,
+        ?RequestContext $requestContext = null,
+        ?SystemContext $systemContext = null,
+        array $metadata = []
+    ): self {
+        return new self(
+            exception: $exceptionContext,
+            request: $requestContext ?? RequestContext::fromGlobals(),
+            system: $systemContext ?? SystemContext::current(),
+            metadata: $metadata
+        );
+    }
+
+    public static function fromException(\Throwable $exception, array $metadata = []): self
+    {
+        $exceptionContext = ExceptionContext::empty();
+
+        if ($exception instanceof FrameworkException) {
+            $exceptionContext = $exception->getContext();
+        }
+
+        return self::create($exceptionContext, metadata: $metadata);
+    }
+
+    public function withMetadata(array $metadata): self
+    {
+        return new self(
+            exception: $this->exception,
+            request: $this->request,
+            system: $this->system,
+            metadata: array_merge($this->metadata, $metadata)
+        );
+    }
+
+    public function withRequest(RequestContext $request): self
+    {
+        return new self(
+            exception: $this->exception,
+            request: $request,
+            system: $this->system,
+            metadata: $this->metadata
+        );
+    }
+
+    public function withSystem(SystemContext $system): self
+    {
+        return new self(
+            exception: $this->exception,
+            request: $this->request,
+            system: $system,
+            metadata: $this->metadata
+        );
+    }
+
+    public function toArray(): array
+    {
+        return [
+            'exception' => $this->exception->toArray(),
+            'request' => $this->request->toArray(),
+            'system' => $this->system->toArray(),
+            'metadata' => $this->metadata
+        ];
+    }
+
+    /**
+     * Gibt eine flache Struktur zurück für einfache Serialisierung
+     */
+    public function toFlatArray(): array
+    {
+        $contexts = [
+            'exception' => $this->exception->toArray(),
+            'request' => $this->request->toArray(),
+            'system' => $this->system->toArray()
+        ];
+
+        $flattened = [];
+        foreach ($contexts as $prefix => $data) {
+            array_walk($data, function($value, $key) use (&$flattened, $prefix) {
+                $flattened[$prefix . '_' . $key] = $value;
+            });
+        }
+
+        return array_merge($flattened, $this->metadata);
+    }
+
+    /**
+     * Extrahiert nur relevante Daten für Logging
+     */
+    public function forLogging(): array
+    {
+        return [
+            'operation' => $this->exception->operation,
+            'component' => $this->exception->component,
+            'client_ip' => $this->request->clientIp,
+            'request_method' => $this->request->requestMethod,
+            'request_uri' => $this->request->requestUri,
+            'memory_usage' => $this->system->memoryUsage,
+            'execution_time' => $this->system->executionTime,
+            'data' => $this->exception->data,
+            'metadata' => $this->metadata
+        ];
+    }
+
+    /**
+     * Generiert Security-Event-Log im OWASP-Format
+     */
+    public function toSecurityEventFormat(string $appId = 'app'): array
+    {
+        $exceptionData = $this->exception->toArray();
+
+        // Basis-Format
+        $securityLog = [
+            'datetime' => date('c'),
+            'appid' => $appId,
+            'level' => 'INFO',
+            'description' => 'No description',
+            'useragent' => $this->request->userAgent,
+            'source_ip' => $this->request->clientIp,
+            'host_ip' => $this->request->hostIp,
+            'hostname' => $this->request->hostname,
+            'protocol' => $this->request->protocol,
+            'port' => $this->request->port,
+            'request_uri' => $this->request->requestUri,
+            'request_method' => $this->request->requestMethod,
+            'region' => $_ENV['AWS_REGION'] ?? 'unknown',
+            'geo' => $_ENV['GEO_LOCATION'] ?? 'unknown'
+        ];
+
+        // Security-Event-spezifische Daten falls verfügbar
+        if (isset($exceptionData['metadata']['security_event'])) {
+            $securityLog['event'] = $exceptionData['metadata']['security_event'];
+            $securityLog['level'] = $exceptionData['metadata']['security_level'] ?? 'INFO';
+            $securityLog['description'] = $exceptionData['metadata']['security_description'] ?? 'Security event';
+        } else {
+            // Fallback für normale Exceptions
+            $securityLog['event'] = 'application_error';
+            $securityLog['level'] = 'ERROR';
+            $securityLog['description'] = 'Application error occurred';
+        }
+
+        return $securityLog;
+    }
+
+    /**
+     * Generiert JSON für Security-Event-Log
+     */
+    public function toSecurityEventJson(string $appId = 'app'): string
+    {
+        return json_encode($this->toSecurityEventFormat($appId), JSON_UNESCAPED_SLASHES);
+    }
+
+    /**
+     * Factory-Methode um ErrorHandlerContext aus Exception zu erstellen
+     */
+    /*public static function fromException(Throwable $exception, ?MiddlewareContext $middlewareContext = null): self
+    {
+        // Request-Context aufbauen
+        $requestContext = RequestContext::create(
+            clientIp: $_SERVER['REMOTE_ADDR'] ?? 'unknown',
+            userAgent: $_SERVER['HTTP_USER_AGENT'] ?? 'unknown',
+            requestMethod: $_SERVER['REQUEST_METHOD'] ?? 'CLI',
+            requestUri: $_SERVER['REQUEST_URI'] ?? '-',
+            hostIp: $_SERVER['SERVER_ADDR'] ?? 'unknown',
+            hostname: $_SERVER['HTTP_HOST'] ?? 'localhost',
+            protocol: $_SERVER['SERVER_PROTOCOL'] ?? 'HTTP/1.1',
+            port: $_SERVER['SERVER_PORT'] ?? '80',
+            requestId: $middlewareContext?->requestId ?? bin2hex(random_bytes(8))
+        );
+
+        // Exception-Context
+        $exceptionContext = ExceptionContext::fromThrowable($exception);
+
+        // System-Context
+        $systemContext = SystemContext::create(
+            memoryUsage: memory_get_usage(true),
+            peakMemoryUsage: memory_get_peak_usage(true),
+            executionTime: microtime(true) - ($_SERVER['REQUEST_TIME_FLOAT'] ?? microtime(true))
+        );
+
+        return new self(
+            exception: $exceptionContext,
+            request: $requestContext,
+            system: $systemContext,
+            metadata: []
+        );
+    }*/
+}
diff --git a/src/Framework/Exception/ExceptionContext.php b/src/Framework/Exception/ExceptionContext.php
new file mode 100644
index 00000000..de4da727
--- /dev/null
+++ b/src/Framework/Exception/ExceptionContext.php
@@ -0,0 +1,97 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Exception;
+
+/**
+ * Fachlicher Kontext für Exceptions - nur domain-spezifische Informationen
+ */
+final readonly class ExceptionContext
+{
+    public function __construct(
+        public ?string $operation = null,
+        public ?string $component = null,
+        public array $data = [],
+        public array $debug = [],
+        public array $metadata = []
+    ) {}
+
+    public static function empty(): self
+    {
+        return new self();
+    }
+
+    public static function forOperation(string $operation, ?string $component = null): self
+    {
+        return new self(operation: $operation, component: $component);
+    }
+
+    public function withOperation(string $operation, ?string $component = null): self
+    {
+        return new self(
+            operation: $operation,
+            component: $component ?? $this->component,
+            data: $this->data,
+            debug: $this->debug,
+            metadata: $this->metadata
+        );
+    }
+
+    public function withData(array $data): self
+    {
+        return new self(
+            operation: $this->operation,
+            component: $this->component,
+            data: array_merge($this->data, $data),
+            debug: $this->debug,
+            metadata: $this->metadata
+        );
+    }
+
+    public function withDebug(array $debug): self
+    {
+        return new self(
+            operation: $this->operation,
+            component: $this->component,
+            data: $this->data,
+            debug: array_merge($this->debug, $debug),
+            metadata: $this->metadata
+        );
+    }
+
+    public function withMetadata(array $metadata): self
+    {
+        return new self(
+            operation: $this->operation,
+            component: $this->component,
+            data: $this->data,
+            debug: $this->debug,
+            metadata: array_merge($this->metadata, $metadata)
+        );
+    }
+
+    public function toArray(): array
+    {
+        return [
+            'operation' => $this->operation,
+            'component' => $this->component,
+            'data' => $this->sanitizeData($this->data),
+            'debug' => $this->debug,
+            'metadata' => $this->metadata
+        ];
+    }
+
+    private function sanitizeData(array $data): array
+    {
+        $sensitiveKeys = ['password', 'token', 'api_key', 'secret', 'private_key'];
+
+        array_walk_recursive($data, function (&$value, $key) use ($sensitiveKeys) {
+            if (in_array(strtolower($key), $sensitiveKeys)) {
+                $value = '[REDACTED]';
+            }
+        });
+
+        return $data;
+    }
+}
diff --git a/src/Framework/Exception/FrameworkException.php b/src/Framework/Exception/FrameworkException.php
new file mode 100644
index 00000000..71556faf
--- /dev/null
+++ b/src/Framework/Exception/FrameworkException.php
@@ -0,0 +1,73 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Exception;
+
+class FrameworkException extends \RuntimeException
+{
+    protected ExceptionContext $context;
+
+    public function __construct(
+        string $message,
+        int $code = 0,
+        ?\Throwable $previous = null,
+        ?ExceptionContext $context = null
+    ) {
+        parent::__construct($message, $code, $previous);
+        $this->context = $context ?? ExceptionContext::empty();
+    }
+
+    public function getContext(): ExceptionContext
+    {
+        return $this->context;
+    }
+
+    public function withContext(ExceptionContext $context): self
+    {
+        $new = clone $this;
+        $new->context = $context;
+        return $new;
+    }
+
+    public function withOperation(string $operation, ?string $component = null): self
+    {
+        return $this->withContext(
+            $this->context->withOperation($operation, $component)
+        );
+    }
+
+    public function withData(array $data): self
+    {
+        return $this->withContext(
+            $this->context->withData($data)
+        );
+    }
+
+    public function withDebug(array $debug): self
+    {
+        return $this->withContext(
+            $this->context->withDebug($debug)
+        );
+    }
+
+    public function withMetadata(array $metadata): self
+    {
+        return $this->withContext(
+            $this->context->withMetadata($metadata)
+        );
+    }
+
+    public function toArray(): array
+    {
+        return [
+            'class' => static::class,
+            'message' => $this->getMessage(),
+            'code' => $this->getCode(),
+            'file' => $this->getFile(),
+            'line' => $this->getLine(),
+            'context' => $this->context->toArray(),
+            'trace' => $this->getTraceAsString(),
+        ];
+    }
+}
diff --git a/src/Framework/Exception/InErrorHandler.md b/src/Framework/Exception/InErrorHandler.md
new file mode 100644
index 00000000..43809fa2
--- /dev/null
+++ b/src/Framework/Exception/InErrorHandler.md
@@ -0,0 +1,22 @@
+```` php
+// Im ErrorHandler wird jetzt ErrorHandlerContext verwendet
+private function createErrorContext(Throwable $exception, ?MiddlewareContext $context = null): ErrorContext
+{
+$handlerContext = ErrorHandlerContext::fromException($exception, [
+'request_id' => $context?->requestId ?? $this->requestIdGenerator->generate(),
+'timestamp' => date('c'),
+'environment' => $_ENV['APP_ENV'] ?? 'production',
+'debug_mode' => $this->isDebugMode
+]);
+
+    return new ErrorContext(
+        exception: $exception,
+        level: $this->determineErrorLevel($exception),
+        requestId: $context?->requestId ?? $this->requestIdGenerator->generate(),
+        context: $handlerContext, // Jetzt ErrorHandlerContext statt ExceptionContext
+        additionalData: [
+            'memory_usage' => memory_get_peak_usage(true),
+        ]
+    );
+}
+````
diff --git a/src/Framework/Exception/RequestContext.php b/src/Framework/Exception/RequestContext.php
new file mode 100644
index 00000000..335f9104
--- /dev/null
+++ b/src/Framework/Exception/RequestContext.php
@@ -0,0 +1,95 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Exception;
+
+final readonly class RequestContext
+{
+    public function __construct(
+        public ?string $hostIp = null,
+        public ?string $hostname = null,
+        public ?string $protocol = null,
+        public ?string $port = null,
+        public ?string $requestUri = null,
+        public ?string $requestMethod = null,
+        public ?string $userAgent = null,
+        public ?string $clientIp = null,
+        public array $headers = []
+    ) {}
+
+    public static function fromGlobals(): self
+    {
+        return new self(
+            hostIp: $_SERVER['SERVER_ADDR'] ?? null,
+            hostname: $_SERVER['HTTP_HOST'] ?? $_SERVER['SERVER_NAME'] ?? null,
+            protocol: isset($_SERVER['HTTPS']) && $_SERVER['HTTPS'] !== 'off' ? 'https' : 'http',
+            port: $_SERVER['SERVER_PORT'] ?? null,
+            requestUri: $_SERVER['REQUEST_URI'] ?? null,
+            requestMethod: $_SERVER['REQUEST_METHOD'] ?? null,
+            userAgent: $_SERVER['HTTP_USER_AGENT'] ?? null,
+            clientIp: self::getClientIp(),
+            headers: self::getHeaders()
+        );
+    }
+
+    public static function empty(): self
+    {
+        return new self();
+    }
+
+    public function toArray(): array
+    {
+        return [
+            'host_ip' => $this->hostIp,
+            'hostname' => $this->hostname,
+            'protocol' => $this->protocol,
+            'port' => $this->port,
+            'request_uri' => $this->requestUri,
+            'request_method' => $this->requestMethod,
+            'user_agent' => $this->userAgent,
+            'client_ip' => $this->clientIp,
+            'headers' => $this->headers
+        ];
+    }
+
+    private static function getClientIp(): ?string
+    {
+        $ipKeys = [
+            'HTTP_CF_CONNECTING_IP',     // Cloudflare
+            'HTTP_X_FORWARDED_FOR',      // Load balancer/proxy
+            'HTTP_X_FORWARDED',          // Proxy
+            'HTTP_X_CLUSTER_CLIENT_IP',  // Cluster
+            'HTTP_FORWARDED_FOR',        // Proxy
+            'HTTP_FORWARDED',            // Proxy
+            'REMOTE_ADDR'                // Standard
+        ];
+
+        foreach ($ipKeys as $key) {
+            if (!empty($_SERVER[$key])) {
+                $ips = explode(',', $_SERVER[$key]);
+                $ip = trim($ips[0]);
+                if (filter_var($ip, FILTER_VALIDATE_IP, FILTER_FLAG_NO_PRIV_RANGE | FILTER_FLAG_NO_RES_RANGE)) {
+                    return $ip;
+                }
+            }
+        }
+
+        return $_SERVER['REMOTE_ADDR'] ?? null;
+    }
+
+    private static function getHeaders(): array
+    {
+        $headers = [];
+
+        foreach ($_SERVER as $key => $value) {
+            if (str_starts_with($key, 'HTTP_')) {
+                $header = str_replace('_', '-', substr($key, 5));
+                $header = ucwords(strtolower($header), '-');
+                $headers[$header] = $value;
+            }
+        }
+
+        return $headers;
+    }
+}
diff --git a/src/Framework/Exception/SecurityEvent/AuthenticationAccountLockedEvent.php b/src/Framework/Exception/SecurityEvent/AuthenticationAccountLockedEvent.php
new file mode 100644
index 00000000..3a25c821
--- /dev/null
+++ b/src/Framework/Exception/SecurityEvent/AuthenticationAccountLockedEvent.php
@@ -0,0 +1,56 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Exception\SecurityEvent;
+
+use App\Framework\Exception\SecurityLogLevel;
+
+/**
+ * Account-Sperrung Event
+ */
+final readonly class AuthenticationAccountLockedEvent implements SecurityEventInterface
+{
+    public function __construct(
+        public string $userId,
+        public int $attempts
+    ) {}
+
+    public function getEventIdentifier(): string
+    {
+        return "authn_account_locked:{$this->userId},{$this->attempts}";
+    }
+
+    public function getDescription(): string
+    {
+        return "User {$this->userId} account locked after {$this->attempts} failed attempts";
+    }
+
+    public function getLogLevel(): SecurityLogLevel
+    {
+        return SecurityLogLevel::WARN;
+    }
+
+    public function getCategory(): string
+    {
+        return 'authentication';
+    }
+
+    public function requiresAlert(): bool
+    {
+        // Account-Sperrungen sind immer alert-würdig
+        return true;
+    }
+
+    public function toArray(): array
+    {
+        return [
+            'userId' => $this->userId,
+            'attempts' => $this->attempts,
+            'event_identifier' => $this->getEventIdentifier(),
+            'category' => $this->getCategory(),
+            'log_level' => $this->getLogLevel()->value,
+            'requires_alert' => $this->requiresAlert()
+        ];
+    }
+}
diff --git a/src/Framework/Exception/SecurityEvent/AuthenticationLoginFailedEvent.php b/src/Framework/Exception/SecurityEvent/AuthenticationLoginFailedEvent.php
new file mode 100644
index 00000000..8deb6ad5
--- /dev/null
+++ b/src/Framework/Exception/SecurityEvent/AuthenticationLoginFailedEvent.php
@@ -0,0 +1,56 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Exception\SecurityEvent;
+
+use App\Framework\Exception\SecurityLogLevel;
+
+/**
+ * Login-Fehler Event
+ */
+final readonly class AuthenticationLoginFailedEvent implements SecurityEventInterface
+{
+    public function __construct(
+        public string $userId,
+        public string $reason = 'invalid_credentials'
+    ) {}
+
+    public function getEventIdentifier(): string
+    {
+        return "authn_login_fail:{$this->userId}";
+    }
+
+    public function getDescription(): string
+    {
+        return "User {$this->userId} login failure";
+    }
+
+    public function getLogLevel(): SecurityLogLevel
+    {
+        return SecurityLogLevel::WARN;
+    }
+
+    public function getCategory(): string
+    {
+        return 'authentication';
+    }
+
+    public function requiresAlert(): bool
+    {
+        // Login-Fehler sind nicht kritisch genug für sofortige Alerts
+        return false;
+    }
+
+    public function toArray(): array
+    {
+        return [
+            'userId' => $this->userId,
+            'reason' => $this->reason,
+            'event_identifier' => $this->getEventIdentifier(),
+            'category' => $this->getCategory(),
+            'log_level' => $this->getLogLevel()->value,
+            'requires_alert' => $this->requiresAlert()
+        ];
+    }
+}
diff --git a/src/Framework/Exception/SecurityEvent/AuthenticationLoginSuccessAfterFailEvent.php b/src/Framework/Exception/SecurityEvent/AuthenticationLoginSuccessAfterFailEvent.php
new file mode 100644
index 00000000..c0223305
--- /dev/null
+++ b/src/Framework/Exception/SecurityEvent/AuthenticationLoginSuccessAfterFailEvent.php
@@ -0,0 +1,56 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Exception\SecurityEvent;
+
+use App\Framework\Exception\SecurityLogLevel;
+
+/**
+ * Login-Erfolg nach Fehlversuchen Event
+ */
+final readonly class AuthenticationLoginSuccessAfterFailEvent implements SecurityEventInterface
+{
+    public function __construct(
+        public string $userId,
+        public int $retries
+    ) {}
+
+    public function getEventIdentifier(): string
+    {
+        return "authn_login_successafterfail:{$this->userId},{$this->retries}";
+    }
+
+    public function getDescription(): string
+    {
+        return "User {$this->userId} login successfully after {$this->retries} failures";
+    }
+
+    public function getLogLevel(): SecurityLogLevel
+    {
+        return SecurityLogLevel::WARN;
+    }
+
+    public function getCategory(): string
+    {
+        return 'authentication';
+    }
+
+    public function requiresAlert(): bool
+    {
+        // Alert wenn viele Fehlversuche vorausgingen
+        return $this->retries >= 5;
+    }
+
+    public function toArray(): array
+    {
+        return [
+            'userId' => $this->userId,
+            'retries' => $this->retries,
+            'event_identifier' => $this->getEventIdentifier(),
+            'category' => $this->getCategory(),
+            'log_level' => $this->getLogLevel()->value,
+            'requires_alert' => $this->requiresAlert()
+        ];
+    }
+}
diff --git a/src/Framework/Exception/SecurityEvent/AuthenticationLoginSuccessEvent.php b/src/Framework/Exception/SecurityEvent/AuthenticationLoginSuccessEvent.php
new file mode 100644
index 00000000..980c0bd9
--- /dev/null
+++ b/src/Framework/Exception/SecurityEvent/AuthenticationLoginSuccessEvent.php
@@ -0,0 +1,53 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Exception\SecurityEvent;
+
+use App\Framework\Exception\SecurityLogLevel;
+
+/**
+ * Login-Erfolg Event
+ */
+final readonly class AuthenticationLoginSuccessEvent implements SecurityEventInterface
+{
+    public function __construct(
+        public string $userId
+    ) {}
+
+    public function getEventIdentifier(): string
+    {
+        return "authn_login_success:{$this->userId}";
+    }
+
+    public function getDescription(): string
+    {
+        return "User {$this->userId} login successfully";
+    }
+
+    public function getLogLevel(): SecurityLogLevel
+    {
+        return SecurityLogLevel::INFO;
+    }
+
+    public function getCategory(): string
+    {
+        return 'authentication';
+    }
+
+    public function requiresAlert(): bool
+    {
+        return false;
+    }
+
+    public function toArray(): array
+    {
+        return [
+            'userId' => $this->userId,
+            'event_identifier' => $this->getEventIdentifier(),
+            'category' => $this->getCategory(),
+            'log_level' => $this->getLogLevel()->value,
+            'requires_alert' => $this->requiresAlert()
+        ];
+    }
+}
diff --git a/src/Framework/Exception/SecurityEvent/AuthorizationAccessDeniedEvent.php b/src/Framework/Exception/SecurityEvent/AuthorizationAccessDeniedEvent.php
new file mode 100644
index 00000000..bbfdf7c2
--- /dev/null
+++ b/src/Framework/Exception/SecurityEvent/AuthorizationAccessDeniedEvent.php
@@ -0,0 +1,57 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Exception\SecurityEvent;
+
+use App\Framework\Exception\SecurityLogLevel;
+
+/**
+ * Zugriff verweigert Event
+ */
+final readonly class AuthorizationAccessDeniedEvent implements SecurityEventInterface
+{
+    public function __construct(
+        public string $userId,
+        public string $resource,
+        public string $action = 'access'
+    ) {}
+
+    public function getEventIdentifier(): string
+    {
+        return "authz_fail:{$this->userId},{$this->resource}";
+    }
+
+    public function getDescription(): string
+    {
+        return "User {$this->userId} authorization failure for {$this->resource}";
+    }
+
+    public function getLogLevel(): SecurityLogLevel
+    {
+        return SecurityLogLevel::WARN;
+    }
+
+    public function getCategory(): string
+    {
+        return 'authorization';
+    }
+
+    public function requiresAlert(): bool
+    {
+        return false;
+    }
+
+    public function toArray(): array
+    {
+        return [
+            'userId' => $this->userId,
+            'resource' => $this->resource,
+            'action' => $this->action,
+            'event_identifier' => $this->getEventIdentifier(),
+            'category' => $this->getCategory(),
+            'log_level' => $this->getLogLevel()->value,
+            'requires_alert' => $this->requiresAlert()
+        ];
+    }
+}
diff --git a/src/Framework/Exception/SecurityEvent/AuthorizationAdminActionEvent.php b/src/Framework/Exception/SecurityEvent/AuthorizationAdminActionEvent.php
new file mode 100644
index 00000000..2e64318d
--- /dev/null
+++ b/src/Framework/Exception/SecurityEvent/AuthorizationAdminActionEvent.php
@@ -0,0 +1,58 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Exception\SecurityEvent;
+
+use App\Framework\Exception\SecurityLogLevel;
+
+/**
+ * Admin-Aktion Event
+ */
+final readonly class AuthorizationAdminActionEvent implements SecurityEventInterface
+{
+    public function __construct(
+        public string $userId,
+        public string $resource,
+        public string $action = 'admin_action'
+    ) {}
+
+    public function getEventIdentifier(): string
+    {
+        return "authz_admin:{$this->userId},{$this->resource}";
+    }
+
+    public function getDescription(): string
+    {
+        return "User {$this->userId} administrative action on {$this->resource}";
+    }
+
+    public function getLogLevel(): SecurityLogLevel
+    {
+        return SecurityLogLevel::WARN;
+    }
+
+    public function getCategory(): string
+    {
+        return 'authorization';
+    }
+
+    public function requiresAlert(): bool
+    {
+        // Admin-Aktionen sind immer beobachtungswürdig
+        return true;
+    }
+
+    public function toArray(): array
+    {
+        return [
+            'userId' => $this->userId,
+            'resource' => $this->resource,
+            'action' => $this->action,
+            'event_identifier' => $this->getEventIdentifier(),
+            'category' => $this->getCategory(),
+            'log_level' => $this->getLogLevel()->value,
+            'requires_alert' => $this->requiresAlert()
+        ];
+    }
+}
diff --git a/src/Framework/Exception/SecurityEvent/InputSqlInjectionAttemptEvent.php b/src/Framework/Exception/SecurityEvent/InputSqlInjectionAttemptEvent.php
new file mode 100644
index 00000000..da6aa7af
--- /dev/null
+++ b/src/Framework/Exception/SecurityEvent/InputSqlInjectionAttemptEvent.php
@@ -0,0 +1,57 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Exception\SecurityEvent;
+
+use App\Framework\Exception\SecurityException;
+use App\Framework\Exception\SecurityLogLevel;
+
+/**
+ * SQL-Injection-Versuch Event
+ */
+final readonly class InputSqlInjectionAttemptEvent implements SecurityEventInterface
+{
+    public function __construct(
+        public string $field,
+        public string $detectedPattern = 'generic_sql_pattern'
+    ) {}
+
+    public function getEventIdentifier(): string
+    {
+        return "input_sql_injection:{$this->field}";
+    }
+
+    public function getDescription(): string
+    {
+        return "SQL injection attempt detected in field {$this->field}";
+    }
+
+    public function getLogLevel(): SecurityLogLevel
+    {
+        return SecurityLogLevel::ERROR;
+    }
+
+    public function getCategory(): string
+    {
+        return 'input_validation';
+    }
+
+    public function requiresAlert(): bool
+    {
+        // SQL-Injection-Versuche sind immer kritisch
+        return true;
+    }
+
+    public function toArray(): array
+    {
+        return [
+            'field' => $this->field,
+            'detectedPattern' => $this->detectedPattern,
+            'event_identifier' => $this->getEventIdentifier(),
+            'category' => $this->getCategory(),
+            'log_level' => $this->getLogLevel()->value,
+            'requires_alert' => $this->requiresAlert()
+        ];
+    }
+}
diff --git a/src/Framework/Exception/SecurityEvent/InputXssAttemptEvent.php b/src/Framework/Exception/SecurityEvent/InputXssAttemptEvent.php
new file mode 100644
index 00000000..061359c7
--- /dev/null
+++ b/src/Framework/Exception/SecurityEvent/InputXssAttemptEvent.php
@@ -0,0 +1,55 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Exception\SecurityEvent;
+
+use App\Framework\Exception\SecurityLogLevel;
+
+/**
+ * XSS-Versuch Event
+ */
+final readonly class InputXssAttemptEvent implements SecurityEventInterface
+{
+    public function __construct(
+        public string $field,
+        public string $detectedPattern = 'generic_xss_pattern'
+    ) {}
+
+    public function getEventIdentifier(): string
+    {
+        return "input_xss_attempt:{$this->field}";
+    }
+
+    public function getDescription(): string
+    {
+        return "XSS attack attempt detected in field {$this->field}";
+    }
+
+    public function getLogLevel(): SecurityLogLevel
+    {
+        return SecurityLogLevel::WARN;
+    }
+
+    public function getCategory(): string
+    {
+        return 'input_validation';
+    }
+
+    public function requiresAlert(): bool
+    {
+        return true;
+    }
+
+    public function toArray(): array
+    {
+        return [
+            'field' => $this->field,
+            'detectedPattern' => $this->detectedPattern,
+            'event_identifier' => $this->getEventIdentifier(),
+            'category' => $this->getCategory(),
+            'log_level' => $this->getLogLevel()->value,
+            'requires_alert' => $this->requiresAlert()
+        ];
+    }
+}
diff --git a/src/Framework/Exception/SecurityEvent/SecurityEventInterface.php b/src/Framework/Exception/SecurityEvent/SecurityEventInterface.php
new file mode 100644
index 00000000..4391e461
--- /dev/null
+++ b/src/Framework/Exception/SecurityEvent/SecurityEventInterface.php
@@ -0,0 +1,43 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Exception\SecurityEvent;
+
+use App\Framework\Exception\SecurityLogLevel;
+
+/**
+ * Interface für alle Security-Event Value Objects
+ */
+interface SecurityEventInterface
+{
+    /**
+     * Gibt den OWASP-Event-Identifier zurück (z.B. "authn_login_fail:user123")
+     */
+    public function getEventIdentifier(): string;
+
+    /**
+     * Gibt die OWASP-Beschreibung zurück (z.B. "User user123 login failure")
+     */
+    public function getDescription(): string;
+
+    /**
+     * Gibt das Log-Level zurück
+     */
+    public function getLogLevel(): SecurityLogLevel;
+
+    /**
+     * Prüft ob Event kritisch ist und Alerting erfordert
+     */
+    public function requiresAlert(): bool;
+
+    /**
+     * Gibt die Event-Daten als Array zurück
+     */
+    public function toArray(): array;
+
+    /**
+     * Gibt die Event-Kategorie zurück (auth, authz, input, etc.)
+     */
+    public function getCategory(): string;
+}
diff --git a/src/Framework/Exception/SecurityEvent/SystemExcessiveUseEvent.php b/src/Framework/Exception/SecurityEvent/SystemExcessiveUseEvent.php
new file mode 100644
index 00000000..3ec571cc
--- /dev/null
+++ b/src/Framework/Exception/SecurityEvent/SystemExcessiveUseEvent.php
@@ -0,0 +1,58 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Exception\SecurityEvent;
+
+use App\Framework\Exception\SecurityLogLevel;
+
+/**
+ * Exzessive Nutzung Event
+ */
+final readonly class SystemExcessiveUseEvent implements SecurityEventInterface
+{
+    public function __construct(
+        public string $identifier,
+        public int $limit,
+        public int $currentUsage
+    ) {}
+
+    public function getEventIdentifier(): string
+    {
+        return "excessive_use:{$this->identifier},{$this->limit}";
+    }
+
+    public function getDescription(): string
+    {
+        return "Excessive usage detected for {$this->identifier} exceeding limit {$this->limit}";
+    }
+
+    public function getLogLevel(): SecurityLogLevel
+    {
+        return SecurityLogLevel::WARN;
+    }
+
+    public function getCategory(): string
+    {
+        return 'system';
+    }
+
+    public function requiresAlert(): bool
+    {
+        // Rate-Limiting-Verletzungen sind immer alert-würdig
+        return true;
+    }
+
+    public function toArray(): array
+    {
+        return [
+            'identifier' => $this->identifier,
+            'limit' => $this->limit,
+            'currentUsage' => $this->currentUsage,
+            'event_identifier' => $this->getEventIdentifier(),
+            'category' => $this->getCategory(),
+            'log_level' => $this->getLogLevel()->value,
+            'requires_alert' => $this->requiresAlert()
+        ];
+    }
+}
diff --git a/src/Framework/Exception/SecurityException.php b/src/Framework/Exception/SecurityException.php
new file mode 100644
index 00000000..111fb230
--- /dev/null
+++ b/src/Framework/Exception/SecurityException.php
@@ -0,0 +1,103 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Exception;
+
+use App\Framework\Exception\SecurityEvent\SecurityEventInterface;
+
+/**
+ * Security-spezifische Exception mit OWASP-konformen Event-Logging
+ */
+class SecurityException extends FrameworkException
+{
+    protected SecurityEventInterface $securityEvent;
+
+    public function __construct(
+        SecurityEventInterface $securityEvent,
+        string $message = '',
+        int $code = 0,
+        ?\Throwable $previous = null,
+        ?ExceptionContext $additionalContext = null
+    ) {
+        $this->securityEvent = $securityEvent;
+
+        // Erstelle Security-Context
+        $context = $this->createSecurityContext($securityEvent, $additionalContext);
+
+        // Verwende Event-Beschreibung als Message falls nicht gesetzt
+        $finalMessage = $message ?: $securityEvent->getDescription();
+
+        parent::__construct($finalMessage, $code, $previous, $context);
+    }
+
+    /**
+     * Factory Method für Security-Events
+     */
+    public static function fromEvent(SecurityEventInterface $event, string $message = '', int $code = 0): self
+    {
+        return new self($event, $message, $code);
+    }
+
+    /**
+     * Erstellt Security-spezifischen Context
+     */
+    private function createSecurityContext(
+        SecurityEventInterface $securityEvent,
+        ?ExceptionContext $additionalContext
+    ): ExceptionContext {
+        $baseContext = ExceptionContext::forOperation(
+            'security.' . $securityEvent->getCategory(),
+            'Security'
+        )->withData([
+            'event_type' => $securityEvent->getEventIdentifier(),
+            'event_category' => $securityEvent->getCategory(),
+            'event_data' => $securityEvent->toArray(),
+            'client_ip' => $_SERVER['REMOTE_ADDR'] ?? 'unknown',
+            'user_agent' => $_SERVER['HTTP_USER_AGENT'] ?? 'unknown',
+            'request_uri' => $_SERVER['REQUEST_URI'] ?? null,
+            'request_method' => $_SERVER['REQUEST_METHOD'] ?? null,
+            'timestamp' => time()
+        ])->withMetadata([
+            'security_event' => $securityEvent->getEventIdentifier(),
+            'security_level' => $securityEvent->getLogLevel()->value,
+            'security_description' => $securityEvent->getDescription(),
+            'requires_alert' => $securityEvent->requiresAlert(),
+            'event_category' => $securityEvent->getCategory()
+        ]);
+
+        // Merge mit zusätzlichem Context falls vorhanden
+        if ($additionalContext) {
+            $baseContext = $baseContext
+                ->withData($additionalContext->data)
+                ->withDebug($additionalContext->debug)
+                ->withMetadata($additionalContext->metadata);
+        }
+
+        return $baseContext;
+    }
+
+    /**
+     * Gibt Security-Event zurück
+     */
+    public function getSecurityEvent(): SecurityEventInterface
+    {
+        return $this->securityEvent;
+    }
+
+    /**
+     * Gibt Security-Level zurück
+     */
+    public function getSecurityLevel(): SecurityLogLevel
+    {
+        return $this->securityEvent->getLogLevel();
+    }
+
+    /**
+     * Prüft ob Alert erforderlich ist
+     */
+    public function requiresAlert(): bool
+    {
+        return $this->securityEvent->requiresAlert();
+    }
+}
diff --git a/src/Framework/Exception/SecurityLogLevel.php b/src/Framework/Exception/SecurityLogLevel.php
new file mode 100644
index 00000000..78cd15e7
--- /dev/null
+++ b/src/Framework/Exception/SecurityLogLevel.php
@@ -0,0 +1,45 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Exception;
+
+/**
+ * Security-spezifische Log-Level nach OWASP-Standard
+ */
+enum SecurityLogLevel: string
+{
+    case DEBUG = 'DEBUG';
+    case INFO = 'INFO';
+    case WARN = 'WARN';
+    case ERROR = 'ERROR';
+    case FATAL = 'FATAL';
+
+    /**
+     * Konvertiert zu Standard-PSR-Log-Level
+     */
+    public function toPsrLevel(): string
+    {
+        return match ($this) {
+            self::DEBUG => 'debug',
+            self::INFO => 'info',
+            self::WARN => 'warning',
+            self::ERROR => 'error',
+            self::FATAL => 'critical',
+        };
+    }
+
+    /**
+     * Numerischer Wert für Vergleiche
+     */
+    public function getNumericValue(): int
+    {
+        return match ($this) {
+            self::DEBUG => 100,
+            self::INFO => 200,
+            self::WARN => 300,
+            self::ERROR => 400,
+            self::FATAL => 500,
+        };
+    }
+}
diff --git a/src/Framework/Exception/SystemContext.php b/src/Framework/Exception/SystemContext.php
new file mode 100644
index 00000000..7a369c69
--- /dev/null
+++ b/src/Framework/Exception/SystemContext.php
@@ -0,0 +1,63 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Exception;
+
+final readonly class SystemContext
+{
+    public function __construct(
+        public ?string $memoryUsage = null,
+        public ?float $executionTime = null,
+        public ?string $phpVersion = null,
+        public ?string $frameworkVersion = null,
+        public array $environment = []
+    ) {}
+
+    public static function current(): self
+    {
+        return new self(
+            memoryUsage: self::formatBytes(memory_get_usage(true)),
+            executionTime: isset($_SERVER['REQUEST_TIME_FLOAT'])
+                ? microtime(true) - $_SERVER['REQUEST_TIME_FLOAT']
+                : null,
+            phpVersion: PHP_VERSION,
+            frameworkVersion: '1.0.0', // Aus Config laden
+            environment: [
+                'os' => PHP_OS,
+                'sapi' => PHP_SAPI,
+                'timezone' => date_default_timezone_get(),
+                'memory_limit' => ini_get('memory_limit'),
+                'max_execution_time' => ini_get('max_execution_time')
+            ]
+        );
+    }
+
+    public static function empty(): self
+    {
+        return new self();
+    }
+
+    public function toArray(): array
+    {
+        return [
+            'memory_usage' => $this->memoryUsage,
+            'execution_time' => $this->executionTime,
+            'php_version' => $this->phpVersion,
+            'framework_version' => $this->frameworkVersion,
+            'environment' => $this->environment
+        ];
+    }
+
+    private static function formatBytes(int $bytes): string
+    {
+        $units = ['B', 'KB', 'MB', 'GB'];
+        $bytes = max($bytes, 0);
+        $pow = floor(($bytes ? log($bytes) : 0) / log(1024));
+        $pow = min($pow, count($units) - 1);
+
+        $bytes /= (1 << (10 * $pow));
+
+        return round($bytes, 2) . ' ' . $units[$pow];
+    }
+}
diff --git a/src/Framework/Exception/ValidationException.php b/src/Framework/Exception/ValidationException.php
new file mode 100644
index 00000000..61b754fb
--- /dev/null
+++ b/src/Framework/Exception/ValidationException.php
@@ -0,0 +1,123 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Exception;
+
+final class ValidationException extends FrameworkException
+{
+    public readonly ValidationResult $validationResult;
+    public readonly array $errors;
+    public readonly string $field;
+
+    /**
+     * @param ValidationResult $validationResult Das Validierungsergebnis mit allen Fehlern
+     * @param string|null $field Optionaler einzelner Feldname für Rückwärtskompatibilität
+     */
+    public function __construct(
+        ValidationResult $validationResult,
+        ?string $field = null
+    ) {
+        $this->validationResult = $validationResult;
+
+        // Für Rückwärtskompatibilität: Wenn nur ein Feld angegeben wurde, verwende dessen Fehler
+        if ($field !== null && $validationResult->getFieldErrors($field)) {
+            $this->field = $field;
+            $this->errors = $validationResult->getFieldErrors($field);
+        } else {
+            // Andernfalls verwende das erste Feld oder einen Standard
+            $allErrors = $validationResult->getAll();
+            $firstField = array_key_first($allErrors);
+            $this->field = $firstField ?? 'unknown';
+            $this->errors = $firstField ? $allErrors[$firstField] : [];
+        }
+
+        // Erstelle eine aussagekräftige Fehlernachricht aus allen Fehlern
+        $message = $this->createErrorMessage();
+
+        // Erstelle Exception-Kontext
+        $context = ExceptionContext::forOperation('validation.validate', 'Validator')
+            ->withData([
+                'failed_fields' => array_keys($validationResult->getAll()),
+                'error_count' => count($validationResult->getAllErrorMessages()),
+                'primary_field' => $this->field,
+                'validation_errors' => $validationResult->getAll()
+            ]);
+
+        parent::__construct(message: $message, context: $context);
+    }
+
+    /**
+     * Erstellt eine strukturierte Fehlernachricht aus allen Validierungsfehlern
+     */
+    private function createErrorMessage(): string
+    {
+        $allErrors = $this->validationResult->getAll();
+
+        if (empty($allErrors)) {
+            return 'Unbekannter Validierungsfehler.';
+        }
+
+        $messages = [];
+        foreach ($allErrors as $field => $fieldErrors) {
+            $fieldMessage = $field . ': ' . implode(', ', $fieldErrors);
+            $messages[] = $fieldMessage;
+        }
+
+        return implode('; ', $messages);
+    }
+
+    /**
+     * Gibt alle Fehlermeldungen für ein bestimmtes Feld zurück
+     *
+     * @param string $field Feldname
+     * @return array<string> Liste der Fehlermeldungen für das Feld
+     */
+    public function getFieldErrors(string $field): array
+    {
+        return $this->validationResult->getFieldErrors($field);
+    }
+
+    /**
+     * Gibt alle Fehlermeldungen als Array zurück
+     *
+     * @return array<string, string[]> Alle Fehlermeldungen gruppiert nach Feldern
+     */
+    public function getAllErrors(): array
+    {
+        return $this->validationResult->getAll();
+    }
+
+    /**
+     * Gibt alle Fehlermeldungen als flache Liste zurück
+     *
+     * @return array<string> Liste aller Fehlermeldungen
+     */
+    public function getAllErrorMessages(): array
+    {
+        return $this->validationResult->getAllErrorMessages();
+    }
+
+    /**
+     * Prüft, ob ein bestimmtes Feld Fehler hat
+     */
+    public function hasFieldErrors(string $field): bool
+    {
+        return !empty($this->validationResult->getFieldErrors($field));
+    }
+
+    /**
+     * Statische Factory-Methode für einfache Einzelfeld-Fehler (Rückwärtskompatibilität)
+     *
+     * @param array<string> $errors Liste der Fehlermeldungen
+     * @param string $field Feldname
+     * @return self
+     */
+    public static function forField(array $errors, string $field): self
+    {
+        $validationResult = new ValidationResult();
+        $validationResult->addErrors($field, $errors);
+
+        return new self($validationResult, $field);
+    }
+}
diff --git a/src/Framework/Filesystem/Directory.php b/src/Framework/Filesystem/Directory.php
new file mode 100644
index 00000000..4c25e83c
--- /dev/null
+++ b/src/Framework/Filesystem/Directory.php
@@ -0,0 +1,122 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Filesystem;
+
+/**
+ * Repräsentiert ein Verzeichnis im Dateisystem mit Lazy-Loading-Unterstützung.
+ *
+ * @property-read string $path Pfad zum Verzeichnis
+ * @property-read Storage $storage Storage-Implementierung
+ * @property-read array $contents Verzeichnisinhalt (lazy geladen)
+ */
+final readonly class Directory
+{
+    public function __construct(
+        public string $path,
+        public Storage $storage,
+        public array $contents = []
+    ) {}
+
+    /**
+     * Prüft, ob das Verzeichnis existiert
+     */
+    public function exists(): bool
+    {
+        return is_dir($this->path);
+    }
+
+    /**
+     * Erstellt das Verzeichnis, falls es nicht existiert
+     */
+    public function create(int $permissions = 0755, bool $recursive = true): void
+    {
+        $this->storage->createDirectory($this->path, $permissions, $recursive);
+    }
+
+    /**
+     * Gibt alle Dateien im Verzeichnis zurück
+     *
+     * @return File[] Liste von Dateiobjekten
+     */
+    public function getFiles(): array
+    {
+        $paths = $this->storage->listDirectory($this->path);
+        $files = [];
+
+        foreach ($paths as $path) {
+            if (is_file($path)) {
+                $files[] = FilesystemFactory::createFile($path, $this->storage);
+            }
+        }
+
+        return $files;
+    }
+
+    /**
+     * Gibt alle Unterverzeichnisse zurück
+     *
+     * @return Directory[] Liste von Verzeichnisobjekten
+     */
+    public function getDirectories(): array
+    {
+        $paths = $this->storage->listDirectory($this->path);
+        $directories = [];
+
+        foreach ($paths as $path) {
+            if (is_dir($path)) {
+                $directories[] = FilesystemFactory::createDirectory($path, $this->storage);
+            }
+        }
+
+        return $directories;
+    }
+
+    /**
+     * Gibt alle Dateien und Unterverzeichnisse in einem Durchgang zurück
+     *
+     * @return array{files: File[], directories: Directory[]}
+     */
+    public function getContents(): array
+    {
+        $paths = $this->storage->listDirectory($this->path);
+        $files = [];
+        $directories = [];
+
+        foreach ($paths as $path) {
+            if (is_file($path)) {
+                $files[] = FilesystemFactory::createFile($path, $this->storage);
+            } elseif (is_dir($path)) {
+                $directories[] = FilesystemFactory::createDirectory($path, $this->storage);
+            }
+        }
+
+        return ['files' => $files, 'directories' => $directories];
+    }
+
+    /**
+     * Gibt eine Datei im Verzeichnis zurück
+     */
+    public function getFile(string $filename): File
+    {
+        $path = $this->path . DIRECTORY_SEPARATOR . $filename;
+        return FilesystemFactory::createFile($path, $this->storage);
+    }
+
+    /**
+     * Gibt ein Unterverzeichnis zurück
+     */
+    public function getDirectory(string $name): Directory
+    {
+        $path = $this->path . DIRECTORY_SEPARATOR . $name;
+        return FilesystemFactory::createDirectory($path, $this->storage);
+    }
+
+    /**
+     * Lädt den Verzeichnisinhalt neu
+     */
+    public function refresh(): Directory
+    {
+        return FilesystemFactory::createDirectory($this->path, $this->storage);
+    }
+}
diff --git a/src/Framework/Filesystem/Exceptions/DirectoryCreateException.php b/src/Framework/Filesystem/Exceptions/DirectoryCreateException.php
new file mode 100644
index 00000000..1710280b
--- /dev/null
+++ b/src/Framework/Filesystem/Exceptions/DirectoryCreateException.php
@@ -0,0 +1,23 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Filesystem\Exceptions;
+
+use App\Framework\Exception\FrameworkException;
+
+final class DirectoryCreateException extends FrameworkException
+{
+    public function __construct(
+        string $directory,
+        int $code = 0,
+        ?\Throwable $previous = null
+    ) {
+        parent::__construct(
+            message: "Ordner '$directory' konnte nicht angelegt werden.",
+            code: $code,
+            previous: $previous,
+            context: ['directory' => $directory]
+        );
+    }
+}
diff --git a/src/Framework/Filesystem/Exceptions/DirectoryListException.php b/src/Framework/Filesystem/Exceptions/DirectoryListException.php
new file mode 100644
index 00000000..fb638373
--- /dev/null
+++ b/src/Framework/Filesystem/Exceptions/DirectoryListException.php
@@ -0,0 +1,23 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Filesystem\Exceptions;
+
+use App\Framework\Exception\FrameworkException;
+
+final class DirectoryListException extends FrameworkException
+{
+    public function __construct(
+        string $directory,
+        int $code = 0,
+        ?\Throwable $previous = null
+    ) {
+        parent::__construct(
+            message: "Fehler beim Auslesen des Verzeichnisses '$directory'.",
+            code: $code,
+            previous: $previous,
+            context: ['directory' => $directory]
+        );
+    }
+}
diff --git a/src/Framework/Filesystem/Exceptions/FileCopyException.php b/src/Framework/Filesystem/Exceptions/FileCopyException.php
new file mode 100644
index 00000000..59464950
--- /dev/null
+++ b/src/Framework/Filesystem/Exceptions/FileCopyException.php
@@ -0,0 +1,27 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Filesystem\Exceptions;
+
+use App\Framework\Exception\FrameworkException;
+
+final class FileCopyException extends FrameworkException
+{
+    public function __construct(
+        string $source,
+        string $destination,
+        int $code = 0,
+        ?\Throwable $previous = null
+    ) {
+        parent::__construct(
+            message: "Fehler beim Kopieren von '$source' nach '$destination'.",
+            code: $code,
+            previous: $previous,
+            context: [
+                'source' => $source,
+                'destination' => $destination
+            ]
+        );
+    }
+}
diff --git a/src/Framework/Filesystem/Exceptions/FileDeleteException.php b/src/Framework/Filesystem/Exceptions/FileDeleteException.php
new file mode 100644
index 00000000..3da5be99
--- /dev/null
+++ b/src/Framework/Filesystem/Exceptions/FileDeleteException.php
@@ -0,0 +1,23 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Filesystem\Exceptions;
+
+use App\Framework\Exception\FrameworkException;
+
+final class FileDeleteException extends FrameworkException
+{
+    public function __construct(
+        string $path,
+        int $code = 0,
+        ?\Throwable $previous = null
+    ) {
+        parent::__construct(
+            message: "Fehler beim Löschen der Datei '$path'.",
+            code: $code,
+            previous: $previous,
+            context: ['path' => $path]
+        );
+    }
+}
diff --git a/src/Framework/Filesystem/Exceptions/FileMetadataException.php b/src/Framework/Filesystem/Exceptions/FileMetadataException.php
new file mode 100644
index 00000000..d96dbb7a
--- /dev/null
+++ b/src/Framework/Filesystem/Exceptions/FileMetadataException.php
@@ -0,0 +1,14 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Filesystem\Exceptions;
+
+use App\Framework\Exception\FrameworkException;
+
+final class FileMetadataException extends FrameworkException
+{
+    public function __construct(string $path, ?\Throwable $previous = null)
+    {
+        parent::__construct("Konnte Metadaten für Datei '{$path}' nicht lesen", 0, $previous);
+    }
+}
diff --git a/src/Framework/Filesystem/Exceptions/FileNotFoundException.php b/src/Framework/Filesystem/Exceptions/FileNotFoundException.php
new file mode 100644
index 00000000..667fbf88
--- /dev/null
+++ b/src/Framework/Filesystem/Exceptions/FileNotFoundException.php
@@ -0,0 +1,23 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Filesystem\Exceptions;
+
+use App\Framework\Exception\FrameworkException;
+
+final class FileNotFoundException extends FrameworkException
+{
+    public function __construct(
+        string $path,
+        int $code = 0,
+        ?\Throwable $previous = null
+    ) {
+        parent::__construct(
+            message: "Datei '$path' nicht gefunden.",
+            code: $code,
+            previous: $previous,
+            context: ['path' => $path]
+        );
+    }
+}
diff --git a/src/Framework/Filesystem/Exceptions/FileReadException.php b/src/Framework/Filesystem/Exceptions/FileReadException.php
new file mode 100644
index 00000000..73440398
--- /dev/null
+++ b/src/Framework/Filesystem/Exceptions/FileReadException.php
@@ -0,0 +1,23 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Filesystem\Exceptions;
+
+use App\Framework\Exception\FrameworkException;
+
+final class FileReadException extends FrameworkException
+{
+    public function __construct(
+        string $path,
+        int $code = 0,
+        ?\Throwable $previous = null
+    ) {
+        parent::__construct(
+            message: "Lesefehler bei '$path'.",
+            code: $code,
+            previous: $previous,
+            context: ['path' => $path]
+        );
+    }
+}
diff --git a/src/Framework/Filesystem/Exceptions/FileWriteException.php b/src/Framework/Filesystem/Exceptions/FileWriteException.php
new file mode 100644
index 00000000..c660e4fd
--- /dev/null
+++ b/src/Framework/Filesystem/Exceptions/FileWriteException.php
@@ -0,0 +1,23 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Filesystem\Exceptions;
+
+use App\Framework\Exception\FrameworkException;
+
+final class FileWriteException extends FrameworkException
+{
+    public function __construct(
+        string $path,
+        int $code = 0,
+        ?\Throwable $previous = null
+    ) {
+        parent::__construct(
+            message: "Fehler beim Schreiben in '$path'.",
+            code: $code,
+            previous: $previous,
+            context: ['path' => $path]
+        );
+    }
+}
diff --git a/src/Framework/Filesystem/File.php b/src/Framework/Filesystem/File.php
new file mode 100644
index 00000000..6e95c160
--- /dev/null
+++ b/src/Framework/Filesystem/File.php
@@ -0,0 +1,71 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Filesystem;
+
+/**
+ * Repräsentiert eine Datei im Dateisystem mit Lazy-Loading-Unterstützung.
+ *
+ * @property-read string $path Pfad zur Datei
+ * @property-read Storage $storage Storage-Implementierung
+ * @property-read string $contents Dateiinhalt (lazy geladen)
+ * @property-read int $size Dateigröße in Bytes (lazy geladen)
+ * @property-read int $lastModified Zeitstempel der letzten Änderung (lazy geladen)
+ */
+final readonly class File
+{
+    public function __construct(
+        public string $path,
+        public Storage $storage,
+        public string $contents = '',
+        public int $size = 0,
+        public int $lastModified = 0
+    ) {}
+
+    /**
+     * Prüft, ob die Datei existiert
+     */
+    public function exists(): bool
+    {
+        return $this->storage->exists($this->path);
+    }
+
+    /**
+     * Löscht die Datei
+     */
+    public function delete(): void
+    {
+        $this->storage->delete($this->path);
+    }
+
+    /**
+     * Kopiert die Datei an einen neuen Ort
+     */
+    public function copyTo(string $destination): File
+    {
+        $this->storage->copy($this->path, $destination);
+        return FilesystemFactory::createFile($destination, $this->storage);
+    }
+
+    /**
+     * Lädt die Dateieigenschaften neu
+     */
+    public function refresh(): File
+    {
+        return FilesystemFactory::createFile($this->path, $this->storage);
+    }
+
+    /**
+     * Holt erweiterte Metadaten der Datei
+     */
+    public function getMetadata(): FileMetadata
+    {
+        return new FileMetadata(
+            size: $this->size,
+            lastModified: $this->lastModified,
+            mimeType: $this->storage->getMimeType($this->path),
+            isReadable: $this->storage->isReadable($this->path),
+            isWritable: $this->storage->isWritable($this->path)
+        );
+    }
+}
diff --git a/src/Framework/Filesystem/FileMetadata.php b/src/Framework/Filesystem/FileMetadata.php
new file mode 100644
index 00000000..64f0ae0f
--- /dev/null
+++ b/src/Framework/Filesystem/FileMetadata.php
@@ -0,0 +1,18 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Filesystem;
+
+/**
+ * Kapselt Metadaten einer Datei.
+ */
+final readonly class FileMetadata
+{
+    public function __construct(
+        public int $size = 0,
+        public int $lastModified = 0,
+        public string $mimeType = '',
+        public bool $isReadable = false,
+        public bool $isWritable = false
+    ) {}
+}
diff --git a/src/Framework/Filesystem/FileStorage.php b/src/Framework/Filesystem/FileStorage.php
new file mode 100644
index 00000000..17d751a4
--- /dev/null
+++ b/src/Framework/Filesystem/FileStorage.php
@@ -0,0 +1,173 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Filesystem;
+
+use App\Framework\Filesystem\Exceptions\DirectoryCreateException;
+use App\Framework\Filesystem\Exceptions\DirectoryListException;
+use App\Framework\Filesystem\Exceptions\FileCopyException;
+use App\Framework\Filesystem\Exceptions\FileDeleteException;
+use App\Framework\Filesystem\Exceptions\FileMetadataException;
+use App\Framework\Filesystem\Exceptions\FileNotFoundException;
+use App\Framework\Filesystem\Exceptions\FileReadException;
+use App\Framework\Filesystem\Exceptions\FileWriteException;
+
+final readonly class FileStorage implements Storage
+{
+    use StorageTrait;
+
+    public function get(string $path): string
+    {
+        if (!is_file($path)) {
+            throw new FileNotFoundException($path);
+        }
+
+        $content = @file_get_contents($path);
+        if ($content === false) {
+            throw new FileReadException($path);
+        }
+        return $content;
+    }
+
+    public function put(string $path, string $content): void
+    {
+        $dir = dirname($path);
+        if (!is_dir($dir)) {
+            if (!@mkdir($dir, 0777, true) && !is_dir($dir)) {
+                throw new DirectoryCreateException($dir);
+            }
+        }
+        if (@file_put_contents($path, $content) === false) {
+            throw new FileWriteException($path);
+        }
+    }
+
+    public function exists(string $path): bool
+    {
+        return is_file($path);
+    }
+
+    public function delete(string $path): void
+    {
+        if (!is_file($path)) {
+            throw new FileNotFoundException($path);
+        }
+
+        if (!@unlink($path)) {
+            throw new FileDeleteException($path);
+        }
+    }
+
+    public function copy(string $source, string $destination): void
+    {
+        if (!is_file($source)) {
+            throw new FileNotFoundException($source);
+        }
+
+        // Stelle sicher, dass das Zielverzeichnis existiert
+        $dir = dirname($destination);
+        if (!is_dir($dir)) {
+            $this->createDirectory($dir);
+        }
+
+        if (!@copy($source, $destination)) {
+            throw new FileCopyException($source, $destination);
+        }
+    }
+
+    public function size(string $path): int
+    {
+        if (!is_file($path)) {
+            throw new FileNotFoundException($path);
+        }
+
+        $size = @filesize($path);
+        if ($size === false) {
+            throw new FileReadException($path);
+        }
+
+        return $size;
+    }
+
+    public function lastModified(string $path): int
+    {
+        if (!is_file($path)) {
+            throw new FileNotFoundException($path);
+        }
+
+        $time = @filemtime($path);
+        if ($time === false) {
+            throw new FileReadException($path);
+        }
+
+        return $time;
+    }
+
+    public function getMimeType(string $path): string
+    {
+        if (!is_file($path)) {
+            throw new FileNotFoundException($path);
+        }
+
+        $mimeType = @mime_content_type($path);
+        if ($mimeType === false) {
+            throw new FileMetadataException($path);
+        }
+
+        return $mimeType;
+    }
+
+    public function isReadable(string $path): bool
+    {
+        if (!is_file($path)) {
+            throw new FileNotFoundException($path);
+        }
+
+        return is_readable($path);
+    }
+
+    public function isWritable(string $path): bool
+    {
+        if (!is_file($path)) {
+            throw new FileNotFoundException($path);
+        }
+
+        return is_writable($path);
+    }
+
+    public function listDirectory(string $directory): array
+    {
+        if (!is_dir($directory)) {
+            throw new DirectoryCreateException($directory);
+        }
+
+        $files = @scandir($directory);
+        if ($files === false) {
+            throw new DirectoryListException($directory);
+        }
+
+        // Entferne . und .. Einträge
+        $files = array_filter($files, function ($file) {
+            return $file !== '.' && $file !== '..';
+        });
+
+        // Vollständige Pfade erstellen
+        $result = [];
+        foreach ($files as $file) {
+            $result[] = $directory . DIRECTORY_SEPARATOR . $file;
+        }
+
+        return array_values($result);
+    }
+
+    public function createDirectory(string $path, int $permissions = 0755, bool $recursive = true): void
+    {
+        if (is_dir($path)) {
+            return; // Verzeichnis existiert bereits
+        }
+
+        if (!@mkdir($path, $permissions, $recursive) && !is_dir($path)) {
+            throw new DirectoryCreateException($path);
+        }
+    }
+}
diff --git a/src/Framework/Filesystem/FilesystemFactory.php b/src/Framework/Filesystem/FilesystemFactory.php
new file mode 100644
index 00000000..e0b01392
--- /dev/null
+++ b/src/Framework/Filesystem/FilesystemFactory.php
@@ -0,0 +1,157 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Filesystem;
+
+use App\Framework\Logging\DefaultLogger;
+use App\Framework\Logging\LogLevel;
+use App\Framework\Logging\LoggerFactory;
+use ReflectionClass;
+
+/**
+ * Factory für Filesystem-Objekte mit Lazy-Loading-Unterstützung.
+ */
+final class FilesystemFactory
+{
+    /**
+     * Erstellt ein File-Objekt mit Lazy-Loading für schwere Eigenschaften.
+     *
+     * @param string $path Pfad zur Datei
+     * @param Storage $storage Storage-Implementierung
+     * @param int|null $cacheTimeoutSeconds Optional, Zeit in Sekunden, nach der der Cache ungültig wird
+     * @param bool $lazyLoad Optional, ob Lazy-Loading verwendet werden soll
+     * @param DefaultLogger|null $logger Optional, Logger für Debug-Informationen
+     */
+    public static function createFile(
+        string $path,
+        Storage $storage,
+        ?int $cacheTimeoutSeconds = null,
+        bool $lazyLoad = true,
+        ?DefaultLogger $logger = null
+    ): File {
+        $logger ??= LoggerFactory::getDefaultLogger();
+
+        // Direkte Instanziierung ohne Lazy-Loading
+        if (!$lazyLoad) {
+            $logger->debug("Erstelle File-Objekt ohne Lazy-Loading: {$path}");
+
+            // Nur laden wenn die Datei existiert
+            if (!$storage->exists($path)) {
+                return new File($path, $storage);
+            }
+
+            return new File(
+                path: $path,
+                storage: $storage,
+                contents: $storage->get($path),
+                size: $storage->size($path),
+                lastModified: $storage->lastModified($path)
+            );
+        }
+
+        $reflection = new ReflectionClass(File::class);
+        $loadTime = time();
+
+        // LazyProxy verwenden für individuelle Property-Callbacks
+        return $reflection->newLazyProxy([
+            // Dateiinhalt wird erst beim ersten Zugriff geladen
+            'contents' => function(File $file) use ($loadTime, $cacheTimeoutSeconds, $logger) {
+                $logger->debug("Lazy-Loading contents für {$file->path}");
+
+                // Cache-Invalidierung basierend auf Zeit
+                if ($cacheTimeoutSeconds !== null && time() - $loadTime > $cacheTimeoutSeconds) {
+                    $logger->debug("Cache-Timeout erreicht für {$file->path}, lade neu");
+                }
+
+                if (!$file->exists()) {
+                    $logger->debug("Datei existiert nicht: {$file->path}");
+                    return '';
+                }
+
+                return $file->storage->get($file->path);
+            },
+
+            // Dateigröße wird erst beim ersten Zugriff ermittelt
+            'size' => function(File $file) use ($loadTime, $cacheTimeoutSeconds, $logger) {
+                $logger->debug("Lazy-Loading size für {$file->path}");
+
+                // Cache-Invalidierung basierend auf Zeit
+                if ($cacheTimeoutSeconds !== null && time() - $loadTime > $cacheTimeoutSeconds) {
+                    $logger->debug("Cache-Timeout erreicht für {$file->path}, lade neu");
+                }
+
+                if (!$file->exists()) {
+                    $logger->debug("Datei existiert nicht: {$file->path}");
+                    return 0;
+                }
+
+                return $file->storage->size($file->path);
+            },
+
+            // Zeitstempel wird erst beim ersten Zugriff ermittelt
+            'lastModified' => function(File $file) use ($loadTime, $cacheTimeoutSeconds, $logger) {
+                $logger->debug("Lazy-Loading lastModified für {$file->path}");
+
+                // Cache-Invalidierung basierend auf Zeit
+                if ($cacheTimeoutSeconds !== null && time() - $loadTime > $cacheTimeoutSeconds) {
+                    $logger->debug("Cache-Timeout erreicht für {$file->path}, lade neu");
+                }
+
+                if (!$file->exists()) {
+                    $logger->debug("Datei existiert nicht: {$file->path}");
+                    return 0;
+                }
+
+                return $file->storage->lastModified($file->path);
+            },
+        ]);
+    }
+
+    /**
+     * Erstellt ein Directory-Objekt mit Lazy-Loading für schwere Eigenschaften.
+     *
+     * @param string $path Pfad zum Verzeichnis
+     * @param Storage $storage Storage-Implementierung
+     * @param bool $lazyLoad Optional, ob Lazy-Loading verwendet werden soll
+     * @param DefaultLogger|null $logger Optional, Logger für Debug-Informationen
+     */
+    public static function createDirectory(
+        string $path,
+        Storage $storage,
+        bool $lazyLoad = true,
+        ?DefaultLogger $logger = null
+    ): Directory {
+        $logger ??= LoggerFactory::getDefaultLogger();
+
+        // Direkte Instanziierung ohne Lazy-Loading
+        if (!$lazyLoad) {
+            $logger->debug("Erstelle Directory-Objekt ohne Lazy-Loading: {$path}");
+
+            $contents = [];
+            if (is_dir($path)) {
+                $contents = $storage->listDirectory($path);
+            }
+
+            return new Directory($path, $storage, $contents);
+        }
+
+        $reflection = new ReflectionClass(Directory::class);
+
+        // LazyGhost verwenden - alle Eigenschaften werden beim ersten Zugriff initialisiert
+        $lazyDir = $reflection->newLazyGhost(
+            // Initializer-Callback
+            function(Directory $directory) use ($logger): void {
+                $logger->debug("Lazy-Loading Directory-Inhalt für {$directory->path}");
+
+                // Verzeichnisinhalt wird erst beim ersten Zugriff auf eine Eigenschaft geladen
+                if ($directory->exists()) {
+                    $directory->contents = $directory->storage->listDirectory($directory->path);
+                } else {
+                    $directory->contents = [];
+                }
+            }
+        );
+        /** @var Directory $lazyDir */
+        return $lazyDir;
+    }
+}
diff --git a/src/Framework/Filesystem/InMemoryStorage.php b/src/Framework/Filesystem/InMemoryStorage.php
new file mode 100644
index 00000000..9f8a813f
--- /dev/null
+++ b/src/Framework/Filesystem/InMemoryStorage.php
@@ -0,0 +1,207 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Filesystem;
+
+use App\Framework\Filesystem\Exceptions\DirectoryCreateException;
+use App\Framework\Filesystem\Exceptions\FileNotFoundException;
+use App\Framework\Filesystem\Exceptions\FileReadException;
+
+/**
+ * In-Memory-Implementierung des Storage-Interfaces für Tests
+ */
+final class InMemoryStorage implements Storage
+{
+    /** @var array<string, string> */
+    private array $files = [];
+
+    /** @var array<string, bool> */
+    private array $directories = [];
+
+    /** @var array<string, int> */
+    private array $timestamps = [];
+
+    public function get(string $path): string
+    {
+        if (!isset($this->files[$path])) {
+            throw new FileNotFoundException($path);
+        }
+
+        return $this->files[$path];
+    }
+
+    public function put(string $path, string $content): void
+    {
+        $dir = dirname($path);
+        if (!isset($this->directories[$dir])) {
+            $this->createDirectory($dir);
+        }
+
+        $this->files[$path] = $content;
+        $this->timestamps[$path] = time();
+    }
+
+    public function exists(string $path): bool
+    {
+        return isset($this->files[$path]);
+    }
+
+    public function delete(string $path): void
+    {
+        if (!isset($this->files[$path])) {
+            throw new FileNotFoundException($path);
+        }
+
+        unset($this->files[$path]);
+        unset($this->timestamps[$path]);
+    }
+
+    public function copy(string $source, string $destination): void
+    {
+        if (!isset($this->files[$source])) {
+            throw new FileNotFoundException($source);
+        }
+
+        $dir = dirname($destination);
+        if (!isset($this->directories[$dir])) {
+            $this->createDirectory($dir);
+        }
+
+        $this->files[$destination] = $this->files[$source];
+        $this->timestamps[$destination] = time();
+    }
+
+    public function size(string $path): int
+    {
+        if (!isset($this->files[$path])) {
+            throw new FileNotFoundException($path);
+        }
+
+        return strlen($this->files[$path]);
+    }
+
+    public function lastModified(string $path): int
+    {
+        if (!isset($this->files[$path])) {
+            throw new FileNotFoundException($path);
+        }
+
+        return $this->timestamps[$path] ?? time();
+    }
+
+    public function listDirectory(string $directory): array
+    {
+        if (!isset($this->directories[$directory])) {
+            throw new DirectoryCreateException($directory);
+        }
+
+        $result = [];
+        $prefix = $directory . DIRECTORY_SEPARATOR;
+        $prefixLength = strlen($prefix);
+
+        // Dateien im Verzeichnis suchen
+        foreach (array_keys($this->files) as $path) {
+            if (str_starts_with($path, $prefix)) {
+                // Nur direkte Kinder, keine tieferen Ebenen
+                $relativePath = substr($path, $prefixLength);
+                if (!str_contains($relativePath, DIRECTORY_SEPARATOR)) {
+                    $result[] = $path;
+                }
+            }
+        }
+
+        // Verzeichnisse im Verzeichnis suchen
+        foreach (array_keys($this->directories) as $path) {
+            if ($path !== $directory && strpos($path, $prefix) === 0) {
+                // Nur direkte Kinder
+                $relativePath = substr($path, $prefixLength);
+                if (!str_contains($relativePath, DIRECTORY_SEPARATOR)) {
+                    $result[] = $path;
+                }
+            }
+        }
+
+        return $result;
+    }
+
+    public function createDirectory(string $path, int $permissions = 0755, bool $recursive = true): void
+    {
+        if (isset($this->directories[$path])) {
+            return; // Verzeichnis existiert bereits
+        }
+
+        if ($recursive) {
+            // Übergeordnete Verzeichnisse erstellen
+            $parent = dirname($path);
+            if ($parent !== '.' && $parent !== '/' && $parent !== $path) {
+                $this->createDirectory($parent, $permissions, true);
+            }
+        }
+
+        $this->directories[$path] = true;
+    }
+
+    /**
+     * Fügt eine Datei direkt zum In-Memory-Speicher hinzu (für Tests)
+     */
+    public function addFile(string $path, string $content): void
+    {
+        $dir = dirname($path);
+        $this->createDirectory($dir);
+        $this->files[$path] = $content;
+        $this->timestamps[$path] = time();
+    }
+
+    /**
+     * Löscht alle Daten im Speicher (für Tests)
+     */
+    public function clear(): void
+    {
+        $this->files = [];
+        $this->directories = [];
+        $this->timestamps = [];
+    }
+
+    /**
+     * Erstellt ein File-Objekt mit Lazy-Loading für teure Eigenschaften
+     */
+    public function file(string $path): File
+    {
+        return FilesystemFactory::createFile($path, $this);
+    }
+
+    /**
+     * Erstellt ein Directory-Objekt mit Lazy-Loading für teure Eigenschaften
+     */
+    public function directory(string $path): Directory
+    {
+        return FilesystemFactory::createDirectory($path, $this);
+    }
+
+    public function getMimeType(string $path): string
+    {
+        if (!isset($this->files[$path])) {
+            throw new FileNotFoundException($path);
+        }
+
+        $finfo = finfo_open(FILEINFO_MIME_TYPE);
+        if ($finfo === false) {
+            throw new FileReadException($path);
+        }
+
+        $mimeType = finfo_buffer($finfo, $this->files[$path]);
+        finfo_close($finfo);
+
+        return $mimeType ?: 'application/octet-stream';
+    }
+
+    public function isReadable(string $path): bool
+    {
+        return true; // Alle Dateien sind im In-Memory-Speicher lesbar
+    }
+
+    public function isWritable(string $path): bool
+    {
+        return true;
+    }
+}
diff --git a/src/Framework/Filesystem/LoggableStorage.php b/src/Framework/Filesystem/LoggableStorage.php
new file mode 100644
index 00000000..c294b578
--- /dev/null
+++ b/src/Framework/Filesystem/LoggableStorage.php
@@ -0,0 +1,102 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Filesystem;
+
+use App\Framework\Logging\DefaultLogger;
+use App\Framework\Logging\LoggerFactory;
+
+/**
+ * Decorator für Storage-Implementierungen mit Logging-Unterstützung.
+ */
+final class LoggableStorage implements Storage
+{
+    use StorageTrait;
+
+    public function __construct(
+        private readonly Storage $storage,
+        private ?DefaultLogger $logger = null
+    ) {
+        $this->logger ??= LoggerFactory::getDefaultLogger();
+    }
+
+    public function get(string $path): string
+    {
+        $this->logger->debug("Lese Datei: {$path}");
+        return $this->storage->get($path);
+    }
+
+    public function put(string $path, string $content): void
+    {
+        $this->logger->debug("Schreibe Datei: {$path}");
+        $this->storage->put($path, $content);
+    }
+
+    public function exists(string $path): bool
+    {
+        $exists = $this->storage->exists($path);
+        $this->logger->debug("Prüfe Existenz: {$path} - " . ($exists ? 'existiert' : 'existiert nicht'));
+        return $exists;
+    }
+
+    public function delete(string $path): void
+    {
+        $this->logger->debug("Lösche Datei: {$path}");
+        $this->storage->delete($path);
+    }
+
+    public function copy(string $source, string $destination): void
+    {
+        $this->logger->debug("Kopiere Datei: {$source} -> {$destination}");
+        $this->storage->copy($source, $destination);
+    }
+
+    public function size(string $path): int
+    {
+        $size = $this->storage->size($path);
+        $this->logger->debug("Dateigröße: {$path} - {$size} Bytes");
+        return $size;
+    }
+
+    public function lastModified(string $path): int
+    {
+        $lastModified = $this->storage->lastModified($path);
+        $this->logger->debug("Letzte Änderung: {$path} - " . date('Y-m-d H:i:s', $lastModified));
+        return $lastModified;
+    }
+
+    public function getMimeType(string $path): string
+    {
+        $mimeType = $this->storage->getMimeType($path);
+        $this->logger->debug("MIME-Typ: {$path} - {$mimeType}");
+        return $mimeType;
+    }
+
+    public function isReadable(string $path): bool
+    {
+        $isReadable = $this->storage->isReadable($path);
+        $this->logger->debug("Lesbar: {$path} - " . ($isReadable ? 'ja' : 'nein'));
+        return $isReadable;
+    }
+
+    public function isWritable(string $path): bool
+    {
+        $isWritable = $this->storage->isWritable($path);
+        $this->logger->debug("Schreibbar: {$path} - " . ($isWritable ? 'ja' : 'nein'));
+        return $isWritable;
+    }
+
+    public function listDirectory(string $directory): array
+    {
+        $this->logger->debug("Liste Verzeichnis: {$directory}");
+        $files = $this->storage->listDirectory($directory);
+        $this->logger->debug("Gefundene Dateien: " . count($files));
+        return $files;
+    }
+
+    public function createDirectory(string $path, int $permissions = 0755, bool $recursive = true): void
+    {
+        $this->logger->debug("Erstelle Verzeichnis: {$path}");
+        $this->storage->createDirectory($path, $permissions, $recursive);
+    }
+}
diff --git a/src/Framework/Filesystem/README.md b/src/Framework/Filesystem/README.md
new file mode 100644
index 00000000..7325d3ac
--- /dev/null
+++ b/src/Framework/Filesystem/README.md
@@ -0,0 +1,68 @@
+# Filesystem-Komponente mit Lazy-Loading
+
+Diese Komponente bietet eine einfache Abstraktion für Dateisystem-Operationen mit Lazy-Loading-Unterstützung für PHP 8.4.
+
+## Funktionen
+
+- **Abstraktion**: Einheitliches Interface für Dateisystem-Operationen
+- **Lazy-Loading**: Optimierte Leistung durch verzögertes Laden von Eigenschaften
+- **Testbarkeit**: In-Memory-Implementierung für Tests
+
+## Verwendungsbeispiele
+
+### Beispiel 1: Datei mit Lazy-Loading verwenden
+
+```php
+// Storage-Implementierung holen
+$storage = new FileStorage();
+
+// Datei-Objekt mit Lazy-Loading erstellen
+$file = $storage->file('/pfad/zur/datei.txt');
+
+// Hier passiert noch kein Disk-I/O
+echo "Datei: {$file->path}\n";
+
+// Erst hier wird der Inhalt tatsächlich geladen
+echo "Inhalt: {$file->contents}\n";
+
+// Und hier die Dateigröße
+echo "Größe: {$file->size} Bytes\n";
+```
+
+### Beispiel 2: Mit Verzeichnissen arbeiten
+
+```php
+// Verzeichnis-Objekt mit Lazy-Loading erstellen
+$dir = $storage->directory('/pfad/zum/verzeichnis');
+
+// Verzeichnis erstellen, falls es nicht existiert
+if (!$dir->exists()) {
+    $dir->create();
+}
+
+// Alle Dateien auflisten (lazy geladen)
+foreach ($dir->getFiles() as $file) {
+    echo "{$file->path}: {$file->size} Bytes\n";
+}
+```
+
+### Beispiel 3: Dateien kopieren und löschen
+
+```php
+$file = $storage->file('/quelle.txt');
+
+// Datei kopieren
+$neueFile = $file->copyTo('/ziel.txt');
+
+// Quelldatei löschen
+$file->delete();
+```
+
+## Technische Details
+
+Die Komponente nutzt die neuen PHP 8.4 Lazy-Loading-Features:
+
+- **ReflectionClass::newLazyProxy()**: Für File-Objekte mit individuellen Property-Callbacks
+- **ReflectionClass::newLazyGhost()**: Für Directory-Objekte mit einheitlichem Initializer
+
+Die Properties werden erst geladen, wenn sie tatsächlich verwendet werden, was besonders bei Verzeichnislisten und großen Dateien zu erheblichen Leistungsverbesserungen führt.
diff --git a/src/Framework/Filesystem/Storage.php b/src/Framework/Filesystem/Storage.php
new file mode 100644
index 00000000..d9089029
--- /dev/null
+++ b/src/Framework/Filesystem/Storage.php
@@ -0,0 +1,78 @@
+<?php
+
+namespace App\Framework\Filesystem;
+
+interface Storage
+{
+    /**
+     * Liest den Inhalt einer Datei
+     */
+    public function get(string $path): string;
+
+    /**
+     * Speichert Inhalt in einer Datei
+     */
+    public function put(string $path, string $content): void;
+
+    /**
+     * Prüft, ob eine Datei existiert
+     */
+    public function exists(string $path): bool;
+
+    /**
+     * Löscht eine Datei
+     */
+    public function delete(string $path): void;
+
+    /**
+     * Kopiert eine Datei
+     */
+    public function copy(string $source, string $destination): void;
+
+    /**
+     * Ermittelt die Größe einer Datei in Bytes
+     */
+    public function size(string $path): int;
+
+    /**
+     * Ermittelt das letzte Änderungsdatum einer Datei
+     */
+    public function lastModified(string $path): int;
+
+    /**
+     * Ermittelt MIME-Typ einer Datei
+     */
+    public function getMimeType(string $path): string;
+
+    /**
+     * Prüft, ob eine Datei lesbar ist
+     */
+    public function isReadable(string $path): bool;
+
+    /**
+     * Prüft, ob eine Datei schreibbar ist
+     */
+    public function isWritable(string $path): bool;
+
+    /**
+     * Liest ein Verzeichnis aus
+     *
+     * @return array<string> Liste von Dateipfaden
+     */
+    public function listDirectory(string $directory): array;
+
+    /**
+     * Erstellt ein Verzeichnis
+     */
+    public function createDirectory(string $path, int $permissions = 0755, bool $recursive = true): void;
+
+    /**
+     * Erstellt ein File-Objekt mit Lazy-Loading
+     */
+    public function file(string $path): File;
+
+    /**
+     * Erstellt ein Directory-Objekt mit Lazy-Loading
+     */
+    public function directory(string $path): Directory;
+}
diff --git a/src/Framework/Filesystem/StorageTrait.php b/src/Framework/Filesystem/StorageTrait.php
new file mode 100644
index 00000000..cdbe8d68
--- /dev/null
+++ b/src/Framework/Filesystem/StorageTrait.php
@@ -0,0 +1,26 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Filesystem;
+
+/**
+ * Stellt Basis-Implementierungen für Storage-Klassen bereit.
+ */
+trait StorageTrait
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function file(string $path): File
+    {
+        return FilesystemFactory::createFile($path, $this);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function directory(string $path): Directory
+    {
+        return FilesystemFactory::createDirectory($path, $this);
+    }
+}
diff --git a/src/Framework/Firewall/FirewallMiddleware.php b/src/Framework/Firewall/FirewallMiddleware.php
new file mode 100644
index 00000000..2f6439ad
--- /dev/null
+++ b/src/Framework/Firewall/FirewallMiddleware.php
@@ -0,0 +1,65 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Firewall;
+
+use App\Framework\Exception\SecurityEvent\InputSqlInjectionAttemptEvent;
+use App\Framework\Exception\SecurityException;
+use App\Framework\Http\HttpMiddleware;
+use App\Framework\Http\MiddlewareContext;
+use App\Framework\Http\MiddlewarePriority;
+use App\Framework\Http\MiddlewarePriorityAttribute;
+use App\Framework\Http\RequestStateManager;
+
+#[MiddlewarePriorityAttribute(MiddlewarePriority::SECURITY)]
+final readonly class FirewallMiddleware implements HttpMiddleware
+{
+
+    public function __invoke(MiddlewareContext $context, callable $next, RequestStateManager $stateManager): MiddlewareContext
+    {
+        $request = $context->request;
+
+        # Bot Blocking
+
+        $userAgent = $request->server->getUserAgent();
+
+        #shoud not be empty:
+        if($userAgent === '') {
+            # Bot detected
+        }
+        $bots = ['Scrapy'];
+        foreach($bots as $bot) {
+            if(str_contains($userAgent, $bot)) {
+                $bot = true;
+            }
+        }
+
+
+
+        $patterns = [
+            '/UNION\s+SELECT/i',
+            '/SELECT.*FROM/i',
+            '/INSERT\s+INTO/i',
+            '/<script.*?>/i',
+            '/javascript:/i',
+            '/\.\.\//',
+            '/%00/',
+        ];
+
+        $dataSources = [
+            $request->path,
+            $request->server->getQueryString(),
+            $request->body,
+        ];
+
+        foreach ($dataSources as $input) {
+            foreach ($patterns as $pattern) {
+                if (preg_match($pattern, $input)) {
+                    throw new SecurityException(new InputSqlInjectionAttemptEvent('field'));
+                }
+            }
+        }
+
+        return $next($context);
+    }
+}
diff --git a/src/Framework/Http/Api/ClientLogController.php b/src/Framework/Http/Api/ClientLogController.php
new file mode 100644
index 00000000..d0628cdb
--- /dev/null
+++ b/src/Framework/Http/Api/ClientLogController.php
@@ -0,0 +1,45 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Http\Api;
+
+use App\Framework\Attributes\Route;
+use App\Framework\Http\Method;
+use App\Framework\Http\Status;
+use App\Framework\Logging\DefaultLogger;
+use App\Framework\Logging\LogLevel;
+use App\Framework\Router\Result\JsonResult;
+
+/**
+ * API-Controller für Client-Logging.
+ * Ermöglicht es dem Frontend, Logs an den Server zu senden und dabei die Request-ID zu verwenden.
+ */
+final readonly class ClientLogController
+{
+    public function __construct(
+        private DefaultLogger $logger
+    ) {}
+
+    #[Route(path: '/api/log', method: Method::POST)]
+    public function __invoke(ClientLogRequest $request): JsonResult
+    {
+        // Log-Level aus dem Client konvertieren
+        $level = match ($request->level) {
+            'error' => LogLevel::ERROR,
+            'warn' => LogLevel::WARNING,
+            'info' => LogLevel::INFO,
+            default => LogLevel::DEBUG,
+        };
+
+        // Log mit Kontext schreiben
+        $this->logger->log($level, "Client: {$request->message}", [
+            'client' => true,
+            'user_agent' => $_SERVER['HTTP_USER_AGENT'] ?? 'unknown',
+            'context' => $request->context ?? [],
+        ]);
+
+        return new JsonResult([
+            'success' => true,
+        ], Status::OK);
+    }
+}
diff --git a/src/Framework/Http/Api/ClientLogRequest.php b/src/Framework/Http/Api/ClientLogRequest.php
new file mode 100644
index 00000000..cda6baeb
--- /dev/null
+++ b/src/Framework/Http/Api/ClientLogRequest.php
@@ -0,0 +1,17 @@
+<?php
+
+namespace App\Framework\Http\Api;
+
+use App\Framework\Http\ControllerRequest;
+
+/**
+ * Request-DTO für den Client-Log-Endpunkt
+ */
+final readonly class ClientLogRequest implements ControllerRequest
+{
+    public function __construct(
+        public string $level,
+        public string $message,
+        public ?array $context = null,
+    ) {}
+}
diff --git a/src/Framework/Http/ControllerRequest.php b/src/Framework/Http/ControllerRequest.php
new file mode 100644
index 00000000..472a9e22
--- /dev/null
+++ b/src/Framework/Http/ControllerRequest.php
@@ -0,0 +1,8 @@
+<?php
+
+namespace App\Framework\Http;
+
+interface ControllerRequest
+{
+
+}
diff --git a/src/Framework/Http/Cookies.php b/src/Framework/Http/Cookies.php
deleted file mode 100644
index 13dd1c34..00000000
--- a/src/Framework/Http/Cookies.php
+++ /dev/null
@@ -1,15 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace App\Framework\Http;
-
-class Cookies
-{
-    /** @var array<string, Cookie> */
-    private array $cookies = [];
-
-    public function __construct(array $rawCookies = [])
-    {
-    }
-}
diff --git a/src/Framework/Http/Cookie.php b/src/Framework/Http/Cookies/Cookie.php
similarity index 91%
rename from src/Framework/Http/Cookie.php
rename to src/Framework/Http/Cookies/Cookie.php
index cf412690..5d54c260 100644
--- a/src/Framework/Http/Cookie.php
+++ b/src/Framework/Http/Cookies/Cookie.php
@@ -2,7 +2,7 @@
 
 declare(strict_types=1);
 
-namespace App\Framework\Http;
+namespace App\Framework\Http\Cookies;
 
 final readonly class Cookie
 {
@@ -22,7 +22,7 @@ final readonly class Cookie
     {
         $cookie = urlencode($this->name) . '=' . urlencode($this->value);
 
-        if ($this->expires !== null) {
+        if ($this->expires !== null && $this->expires > 0) {
             $cookie .= '; Expires=' . gmdate('D, d-M-Y H:i:s T', $this->expires);
         }
 
diff --git a/src/Framework/Http/Cookies/Cookies.php b/src/Framework/Http/Cookies/Cookies.php
new file mode 100644
index 00000000..4f871f3c
--- /dev/null
+++ b/src/Framework/Http/Cookies/Cookies.php
@@ -0,0 +1,24 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Http\Cookies;
+
+final readonly class Cookies
+{
+    /** @var array<string, Cookie> */
+    private array $cookies;
+
+    public function __construct(Cookie ...$cookies)
+    {
+        foreach ($cookies as $cookie) {
+            $cookies[$cookie->name] = $cookie;
+        }
+        $this->cookies = $cookies;
+    }
+
+    public function get(string $name): ?Cookie
+    {
+        return $this->cookies[$name] ?? null;
+    }
+}
diff --git a/src/Framework/Http/Cookies/SameSite.php b/src/Framework/Http/Cookies/SameSite.php
new file mode 100644
index 00000000..0e108cd8
--- /dev/null
+++ b/src/Framework/Http/Cookies/SameSite.php
@@ -0,0 +1,12 @@
+<?php
+
+namespace App\Framework\Http\Cookies;
+
+enum SameSite: string
+{
+    case Strict = 'Strict';
+
+    case Lax = 'Lax';
+
+    case None = 'None';
+}
diff --git a/src/Framework/Http/DOKUMENTATION.md b/src/Framework/Http/DOKUMENTATION.md
new file mode 100644
index 00000000..4e8e3f53
--- /dev/null
+++ b/src/Framework/Http/DOKUMENTATION.md
@@ -0,0 +1,92 @@
+# HTTP-Modul Dokumentation
+
+## Übersicht
+
+Das HTTP-Modul stellt Komponenten für die Verarbeitung von HTTP-Anfragen und -Antworten bereit.
+
+## Hauptkomponenten
+
+### Request
+
+Repräsentiert eine HTTP-Anfrage mit Methoden zum Zugriff auf:
+- HTTP-Methode (`getMethod()`)
+- Pfad (`getPath()`)
+- Query-Parameter (`getQueryParams()`)
+- Request-Body
+- Headers
+
+### Response
+
+Repräsentiert eine HTTP-Antwort mit:
+- Status-Code (`getStatusCode()`)
+- Headers
+- Body
+
+### Middleware
+
+Ein Interface für HTTP-Middleware-Komponenten, die die Request-Verarbeitung verändern können:
+
+```php
+interface Middleware
+{
+    public function process(Request $request, callable $next): Response;
+}
+```
+
+**Beispiel-Middleware:**
+```php
+class AnalyticsMiddleware implements Middleware
+{
+    public function __construct(
+        private readonly Analytics $analytics
+    ) {}
+
+    public function process(Request $request, callable $next): Response
+    {
+        // Request tracken
+        $this->analytics->track('http_request', [
+            'method' => $request->getMethod(),
+            'path' => $request->getPath(),
+        ]);
+
+        // Request weiterleiten
+        $response = $next($request);
+
+        // Response tracken
+        $this->analytics->track('http_response', [
+            'status_code' => $response->getStatusCode(),
+        ]);
+
+        return $response;
+    }
+}
+```
+
+## Integration mit anderen Modulen
+
+- **Router**: Routing von HTTP-Requests zu Controllers
+- **Analytics**: Tracking von HTTP-Requests und -Responses
+- **Validation**: Validierung von Request-Daten
+
+## Middlewares registrieren
+
+In der Anwendungsklasse:
+
+```php
+$this->addMiddleware(LoggingMiddleware::class);
+$this->addMiddleware(AnalyticsMiddleware::class);
+$this->addMiddleware(AuthenticationMiddleware::class);
+```
+
+## Responses erzeugen
+
+```php
+// JSON-Response
+return new JsonResponse(['success' => true]);
+
+// HTML-Response
+return new HtmlResponse('<html><body>Hello World</body></html>');
+
+// Redirect
+return new RedirectResponse('/dashboard');
+```
diff --git a/src/Framework/Http/Emitter/AdaptiveStreamEmitter.php b/src/Framework/Http/Emitter/AdaptiveStreamEmitter.php
new file mode 100644
index 00000000..59c843eb
--- /dev/null
+++ b/src/Framework/Http/Emitter/AdaptiveStreamEmitter.php
@@ -0,0 +1,36 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Http\Emitter;
+
+use App\Framework\Http\Response;
+use App\Framework\Http\Responses\AdaptiveStreamResponse;
+
+final class AdaptiveStreamEmitter implements Emitter
+{
+    public function emit(Response $response): void
+    {
+        if (!$response instanceof AdaptiveStreamResponse) {
+            throw new \InvalidArgumentException('Response must be AdaptiveStreamResponse');
+        }
+
+        // HTTP Status senden
+        http_response_code($response->status->value);
+
+        // Header senden
+        foreach ($response->headers->all() as $name => $values) {
+            foreach ($values as $value) {
+                header("{$name}: {$value}");
+            }
+        }
+
+        // Playlist/Manifest ausgeben
+        echo $response->body;
+
+        if (ob_get_level() > 0) {
+            ob_flush();
+        }
+        flush();
+    }
+}
diff --git a/src/Framework/Http/Emitter/Emitter.php b/src/Framework/Http/Emitter/Emitter.php
new file mode 100644
index 00000000..cc8bf16f
--- /dev/null
+++ b/src/Framework/Http/Emitter/Emitter.php
@@ -0,0 +1,10 @@
+<?php
+
+namespace App\Framework\Http\Emitter;
+
+use App\Framework\Http\Response;
+
+interface Emitter
+{
+    public function emit(Response $response): void;
+}
diff --git a/src/Framework/Http/Emitter/HttpEmitter.php b/src/Framework/Http/Emitter/HttpEmitter.php
new file mode 100644
index 00000000..ce7bff3e
--- /dev/null
+++ b/src/Framework/Http/Emitter/HttpEmitter.php
@@ -0,0 +1,46 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Http\Emitter;
+
+use App\Framework\Http\Emitter\Emitter;
+use App\Framework\Http\Response;
+
+final class HttpEmitter implements Emitter
+{
+
+    public function emit(Response $response): void
+    {
+        // 1. Robustheit: Prüfen, ob Header bereits gesendet wurden.
+        if (headers_sent($file, $line)) {
+            throw new \RuntimeException("Kann die Antwort nicht senden: Header wurden bereits in {$file}:{$line} gesendet.");
+        }
+
+        // 2. Robustheit: Jeglichen zuvor gepufferten Output löschen, um unbeabsichtigte Ausgaben zu vermeiden.
+        if (ob_get_level() > 0 && ob_get_length() > 0) {
+            ob_clean();
+        }
+
+        // Status-Code senden
+        http_response_code($response->status->value);
+
+        // 4. Header senden (korrigierte und vereinfachte Logik)
+        foreach ($response->headers->all() as $name => $value) {
+            // Der `Set-Cookie`-Header ist ein Sonderfall und darf nicht kombiniert werden.
+            if (strtolower($name) === 'set-cookie') {
+                foreach ((array)$value as $cookie) {
+                    header("Set-Cookie: $cookie", false);
+                }
+                // Wichtig: Mit dem nächsten Header fortfahren, um doppeltes Senden zu verhindern.
+                continue;
+            }
+
+            // Alle anderen Header mit mehreren Werten können kombiniert werden.
+            $headerValue = is_array($value) ? implode(', ', $value) : $value;
+            header("$name: $headerValue", true);
+        }
+
+        // Body ausgeben
+        echo $response->body;
+    }
+}
diff --git a/src/Framework/Http/Emitter/SseEmitter.php b/src/Framework/Http/Emitter/SseEmitter.php
new file mode 100644
index 00000000..d802a505
--- /dev/null
+++ b/src/Framework/Http/Emitter/SseEmitter.php
@@ -0,0 +1,71 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Http\Emitter;
+
+use App\Framework\Http\Emitter\Emitter;
+use App\Framework\Http\Response;
+use App\Framework\Http\Responses\SseResponse;
+use App\Framework\Http\SseStream;
+
+final readonly class SseEmitter implements Emitter
+{
+    public function emit(Response $response): void
+    {
+        if($response instanceof SseResponse === false) {
+            throw new \InvalidArgumentException('Response must be an instance of SseResponse');
+        }
+
+        // Stream-Objekt erstellen
+        $stream = new SseStream();
+
+        // Stream starten (sendet Header und initiale Events)
+        $stream->start(
+            $response->headers,
+            $response->status,
+            $response->initialEvents
+        );
+
+        // Streaming-Parameter
+        $startTime = time();
+        $lastHeartbeat = $startTime;
+        $heartbeatInterval = $response->heartbeatInterval;
+        $maxDuration = $response->maxDuration;
+        $callback = $response->streamCallback;
+
+        // Streaming-Loop
+        while ($stream->isConnectionActive()) {
+            // Prüfen, ob die maximale Dauer erreicht wurde
+            if ($maxDuration > 0 && (time() - $startTime) >= $maxDuration) {
+                $stream->sendJson(['message' => 'Maximum duration reached'], 'timeout');
+                break;
+            }
+
+            // Callback ausführen, falls vorhanden
+            if ($callback !== null) {
+                try {
+                    call_user_func($callback, $stream);
+                } catch (\Throwable $e) {
+                    // Fehler im Callback abfangen
+                    $stream->sendJson([
+                        'error' => $e->getMessage(),
+                        'type' => get_class($e)
+                    ], 'error');
+                    break;
+                }
+            }
+
+            // Heartbeat senden
+            if (time() - $lastHeartbeat >= $heartbeatInterval) {
+                $stream->sendHeartbeat();
+                $lastHeartbeat = time();
+            }
+
+            // Kurze Pause, um CPU-Last zu reduzieren
+            usleep(100_000); // 100ms
+        }
+
+        // Stream schließen
+        $stream->close();
+    }
+}
diff --git a/src/Framework/Http/Emitter/StreamEmitter.php b/src/Framework/Http/Emitter/StreamEmitter.php
new file mode 100644
index 00000000..c06cdafc
--- /dev/null
+++ b/src/Framework/Http/Emitter/StreamEmitter.php
@@ -0,0 +1,109 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Http\Emitter;
+
+use App\Framework\Http\Emitter\Emitter;
+use App\Framework\Http\Range;
+use App\Framework\Http\Response;
+use App\Framework\Http\Responses\StreamResponse;
+use App\Framework\Http\Status;
+
+final class StreamEmitter implements Emitter
+{
+
+    public function emit(Response $response): void
+    {
+        if (!$response instanceof StreamResponse) {
+            throw new \InvalidArgumentException('Response must be StreamResponse');
+        }
+
+        $chunkSize = 8192;
+
+        // Range Request verarbeiten
+        if ($response->range !== null) {
+            $this->emitRangeResponse($response, $chunkSize);
+        } else {
+            $this->emitFullResponse($response, $chunkSize);
+        }
+
+    }
+
+    private function emitRangeResponse(StreamResponse $response, int $chunkSize): void
+    {
+        $range = $response->range;
+
+        // 206 Partial Content Status
+        http_response_code(Status::PARTIAL_CONTENT->value);
+
+        // Range-spezifische Header
+        header("Content-Range: bytes {$range->start}-{$range->end}/{$range->total}");
+        header('Content-Length: ' . $range->length);
+        header("Content-Type: {$response->mimeType}");
+        header('Accept-Ranges: bytes');
+
+        // Zusätzliche Header
+        foreach ($response->headers->all() as $name => $value) {
+            $headerValue = is_array($value) ? implode(', ', $value) : $value;
+            header("$name: $headerValue");
+        }
+
+        $this->streamRange($response->filePath, $range, $chunkSize);
+    }
+
+    private function streamRange(string $filePath,Range $range, int $chunkSize): void
+    {
+        // Stream öffnen und zur Start-Position springen
+        $handle = fopen($filePath, 'rb');
+        fseek($handle, $range->start);
+
+        $remaining = $range->length;
+
+        while ($remaining > 0 && !feof($handle)) {
+            $readSize = min($chunkSize, $remaining);
+            $chunk = fread($handle, $readSize);
+
+            echo $chunk;
+
+            $remaining -= strlen($chunk);
+
+            // Output buffer leeren
+            $this->flushOutput();
+        }
+
+        fclose($handle);
+    }
+
+    private function flushOutput(): void
+    {
+        if (ob_get_level() > 0) {
+            ob_flush();
+        }
+        flush();
+    }
+
+    private function emitFullResponse(StreamResponse $response, int $chunkSize): void
+    {
+        // Standard Header
+        http_response_code($response->status->value);
+        header("Content-Type: {$response->mimeType}");
+        header("Content-Length: {$response->fileSize}");
+        header('Accept-Ranges: bytes');
+
+        $this->streamFile($response->filePath, $chunkSize);
+    }
+
+    private function streamFile(string $filePath, int $chunkSize): void
+    {
+        // Stream komplett senden
+        $handle = fopen($filePath, 'rb');
+
+        while (!feof($handle)) {
+            echo fread($handle, $chunkSize);
+
+            $this->flushOutput();
+        }
+
+        fclose($handle);
+    }
+}
diff --git a/src/Framework/Http/Emitter/WebSocketEmitter.php b/src/Framework/Http/Emitter/WebSocketEmitter.php
new file mode 100644
index 00000000..89423c26
--- /dev/null
+++ b/src/Framework/Http/Emitter/WebSocketEmitter.php
@@ -0,0 +1,48 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Http\Emitter;
+
+use App\Framework\Http\Emitter\Emitter;
+use App\Framework\Http\Response;
+use App\Framework\Http\Responses\WebSocketResponse;
+use App\Framework\Http\WebSocketServer;
+
+final class WebSocketEmitter implements Emitter
+{
+    public function __construct(
+        private readonly WebSocketServer $webSocketServer = new WebSocketServer()
+    ) {}
+
+    public function emit(Response $response): void
+    {
+        if($response instanceof WebSocketResponse === false) {
+            throw new \InvalidArgumentException('Response must be an instance of WebSocketResponse');
+        }
+
+        // 1. Robustheit: Prüfen, ob Header bereits gesendet wurden.
+        if (headers_sent($file, $line)) {
+            throw new \RuntimeException("Kann die WebSocket-Antwort nicht senden: Header wurden bereits in {$file}:{$line} gesendet.");
+        }
+
+        // 2. Output-Buffer leeren
+        if (ob_get_level() > 0 && ob_get_length() > 0) {
+            ob_clean();
+        }
+
+        // 3. Status-Code senden
+        http_response_code($response->status->value);
+
+        // 4. Header senden
+        foreach ($response->headers->toArray() as $name => $value) {
+            $headerValue = is_array($value) ? implode(', ', $value) : $value;
+            header("$name: $headerValue", true);
+        }
+
+        // 5. Output-Buffer leeren und alle Header senden
+        flush();
+
+        // 6. WebSocket-Server mit der Verbindung beginnen
+        $this->webSocketServer->handleUpgrade($response);
+    }
+}
diff --git a/src/Framework/Http/Exception/HttpException.php b/src/Framework/Http/Exception/HttpException.php
new file mode 100644
index 00000000..3a3ac0b3
--- /dev/null
+++ b/src/Framework/Http/Exception/HttpException.php
@@ -0,0 +1,12 @@
+<?php
+
+namespace App\Framework\Http\Exception;
+
+use App\Framework\Http\Status;
+
+interface HttpException
+{
+    public Status $status {
+        get;
+    }
+}
diff --git a/src/Framework/Http/Exception/NotFound.php b/src/Framework/Http/Exception/NotFound.php
new file mode 100644
index 00000000..2c018f7d
--- /dev/null
+++ b/src/Framework/Http/Exception/NotFound.php
@@ -0,0 +1,16 @@
+<?php
+
+namespace App\Framework\Http\Exception;
+
+use App\Framework\Exception\FrameworkException;
+use App\Framework\Http\Status;
+
+final class NotFound extends FrameworkException implements HttpException
+{
+
+    public \App\Framework\Http\Status $status {
+        get {
+            return Status::NOT_FOUND;
+        }
+    }
+}
diff --git a/src/Framework/Http/HeaderKey.php b/src/Framework/Http/HeaderKey.php
new file mode 100644
index 00000000..94dc3190
--- /dev/null
+++ b/src/Framework/Http/HeaderKey.php
@@ -0,0 +1,81 @@
+<?php
+declare(strict_types=1);
+
+/**
+ * Enum representing common HTTP header keys.
+ *
+ * Provides a predefined set of constants for HTTP headers used in request and response contexts.
+ * Each constant represents a standard HTTP header name as a string.
+ */
+
+namespace App\Framework\Http;
+
+enum HeaderKey: string
+{
+    case ACCEPT = 'Accept';
+    case ACCEPT_CHARSET = 'Accept-Charset';
+    case ACCEPT_ENCODING = 'Accept-Encoding';
+    case ACCEPT_LANGUAGE = 'Accept-Language';
+    case ACCEPT_RANGES = 'Accept-Ranges';
+    case ACCESS_CONTROL_ALLOW_CREDENTIALS = 'Access-Control-Allow-Credentials';
+    case ACCESS_CONTROL_ALLOW_HEADERS = 'Access-Control-Allow-Headers';
+    case ACCESS_CONTROL_ALLOW_METHODS = 'Access-Control-Allow-Methods';
+    case ACCESS_CONTROL_ALLOW_ORIGIN = 'Access-Control-Allow-Origin';
+    case ACCESS_CONTROL_EXPOSE_HEADERS = 'Access-Control-Expose-Headers';
+    case ACCESS_CONTROL_MAX_AGE = 'Access-Control-Max-Age';
+    case ACCESS_CONTROL_REQUEST_HEADERS = 'Access-Control-Request-Headers';
+    case ACCESS_CONTROL_REQUEST_METHOD = 'Access-Control-Request-Method';
+    case AGE = 'Age';
+    case ALLOW = 'Allow';
+    case AUTHORIZATION = 'Authorization';
+    case CACHE_CONTROL = 'Cache-Control';
+    case CONNECTION = 'Connection';
+    case CONTENT_DISPOSITION = 'Content-Disposition';
+    case CONTENT_ENCODING = 'Content-Encoding';
+    case CONTENT_LANGUAGE = 'Content-Language';
+    case CONTENT_LENGTH = 'Content-Length';
+    case CONTENT_LOCATION = 'Content-Location';
+    case CONTENT_RANGE = 'Content-Range';
+    case CONTENT_SECURITY_POLICY = 'Content-Security-Policy';
+    case CONTENT_TYPE = 'Content-Type';
+    case COOKIE = 'Cookie';
+    case DATE = 'Date';
+    case ETAG = 'ETag';
+    case EXPECT = 'Expect';
+    case EXPIRES = 'Expires';
+    case FORWARDED = 'Forwarded';
+    case FROM = 'From';
+    case HOST = 'Host';
+    case IF_MATCH = 'If-Match';
+    case IF_MODIFIED_SINCE = 'If-Modified-Since';
+    case IF_NONE_MATCH = 'If-None-Match';
+    case IF_RANGE = 'If-Range';
+    case IF_UNMODIFIED_SINCE = 'If-Unmodified-Since';
+    case LAST_MODIFIED = 'Last-Modified';
+    case LINK = 'Link';
+    case LOCATION = 'Location';
+    case MAX_FORWARDS = 'Max-Forwards';
+    case ORIGIN = 'Origin';
+    case PRAGMA = 'Pragma';
+    case PROXY_AUTHENTICATE = 'Proxy-Authenticate';
+    case PROXY_AUTHORIZATION = 'Proxy-Authorization';
+    case RANGE = 'Range';
+    case REFERER = 'Referer';
+    case RETRY_AFTER = 'Retry-After';
+    case SERVER = 'Server';
+    case SET_COOKIE = 'Set-Cookie';
+    case STRICT_TRANSPORT_SECURITY = 'Strict-Transport-Security';
+    case TE = 'TE';
+    case TRAILER = 'Trailer';
+    case TRANSFER_ENCODING = 'Transfer-Encoding';
+    case UPGRADE = 'Upgrade';
+    case USER_AGENT = 'User-Agent';
+    case VARY = 'Vary';
+    case VIA = 'Via';
+    case WARNING = 'Warning';
+    case WWW_AUTHENTICATE = 'WWW-Authenticate';
+    case X_FORWARDED_FOR = 'X-Forwarded-For';
+    case X_FORWARDED_HOST = 'X-Forwarded-Host';
+    case X_FORWARDED_PROTO = 'X-Forwarded-Proto';
+    case X_REQUESTED_WITH = 'X-Requested-With';
+}
diff --git a/src/Framework/Http/HeaderManipulator.php b/src/Framework/Http/HeaderManipulator.php
new file mode 100644
index 00000000..187cd565
--- /dev/null
+++ b/src/Framework/Http/HeaderManipulator.php
@@ -0,0 +1,61 @@
+<?php
+
+namespace App\Framework\Http;
+
+/**
+ * Hilfsklasse für erweiterte Header-Funktionen ohne Modifikation der Headers-Klasse
+ */
+final readonly class HeaderManipulator
+{
+    /**
+     * Konvertiert einen Header-String in ein Headers-Objekt
+     */
+    public static function fromString(string $headersRaw): Headers
+    {
+        $headers = new Headers();
+        // Zeilenumbrüche vereinheitlichen und in Zeilen aufteilen
+        $lines = preg_split('/\r\n|\n|\r/', $headersRaw);
+
+        // Die erste Zeile kann die Status-Zeile sein, die überspringen wir
+        $statusLineFound = false;
+
+        foreach ($lines as $line) {
+            // Leere Zeilen überspringen
+            if (trim($line) === '') {
+                continue;
+            }
+
+            // Status-Zeile (HTTP/1.1 200 OK) überspringen
+            if (!$statusLineFound && preg_match('/^HTTP\/\d\.\d\s+\d+/', $line)) {
+                $statusLineFound = true;
+                continue;
+            }
+
+            // Header im Format "Name: Wert" parsen
+            if (preg_match('/^([^:]+):\s*(.*)$/', $line, $matches)) {
+                $name = $matches[1];
+                $value = $matches[2];
+
+                $headers = $headers->withAdded($name, $value);
+            }
+        }
+
+        return $headers;
+    }
+
+    /**
+     * Formatiert Headers für cURL
+     */
+    public static function formatForCurl(Headers $headers): array
+    {
+        $formattedHeaders = [];
+
+        foreach ($headers->all() as $name => $values) {
+            foreach ($values as $value) {
+                $formattedHeaders[] = "$name: $value";
+            }
+        }
+
+        return $formattedHeaders;
+    }
+}
diff --git a/src/Framework/Http/Headers.php b/src/Framework/Http/Headers.php
index 9f4810f8..ab76ab8d 100644
--- a/src/Framework/Http/Headers.php
+++ b/src/Framework/Http/Headers.php
@@ -2,7 +2,9 @@
 
 namespace App\Framework\Http;
 
-final class Headers
+use InvalidArgumentException;
+
+final readonly class Headers
 {
     /**
      * Struktur:
@@ -16,12 +18,18 @@ final class Headers
      * @var array<string, array{string, string[]}>
      * Struktur: 'normalized-lower-name' => [Original-Name, [Wert1, Wert2, ...]]
      */
-    public function __construct(
-        private readonly array $headers = []
-    ) {}
+    private array $headers;
 
-    public function with(string $name, string|array $value): self
+    public function __construct(
+        array $headers = []
+    ) {
+        $this->headers = $this->parseFromArray($headers);
+    }
+
+    public function with(HeaderKey|string $name, string|array $value): self
     {
+        $name = $this->getNameAsString($name);
+
         $key = strtolower($name);
         $original = $this->normalizeName($name);
         $values = is_array($value) ? array_values($value) : [$value];
@@ -32,8 +40,10 @@ final class Headers
         return new self($new);
     }
 
-    public function withAdded(string $name, string $value): self
+    public function withAdded(HeaderKey|string $name, string $value): self
     {
+        $name = $this->getNameAsString($name);
+
         $key = strtolower($name);
         $original = $this->normalizeName($name);
 
@@ -47,8 +57,10 @@ final class Headers
         return new self($new);
     }
 
-    public function without(string $name): self
+    public function without(HeaderKey|string $name): self
     {
+        $name = $this->getNameAsString($name);
+
         $key = strtolower($name);
         $new = $this->headers;
         unset($new[$key]);
@@ -56,18 +68,22 @@ final class Headers
         return new self($new);
     }
 
-    public function get(string $name): ?array
+    public function get(HeaderKey|string $name): ?array
     {
+        $name = $this->getNameAsString($name);
+
         return $this->headers[strtolower($name)][1] ?? null;
     }
 
-    public function getFirst(string $name): ?string
+    public function getFirst(HeaderKey|string $name): ?string
     {
         return $this->get($name)[0] ?? null;
     }
 
-    public function has(string $name): bool
+    public function has(HeaderKey|string $name): bool
     {
+        $name = $this->getNameAsString($name);
+
         return isset($this->headers[strtolower($name)]);
     }
 
@@ -83,8 +99,92 @@ final class Headers
         return $output;
     }
 
+    /**
+     * Normalizes the given header name by converting it to a canonical format.
+     * Each word in the name is capitalized, and hyphens are preserved.
+     *
+     * @param string $name The header name to be normalized.
+     * @return string The normalized header name.
+     */
     private function normalizeName(string $name): string
     {
         return preg_replace_callback('/(?:^|-)[a-z]/', fn($m) => strtoupper($m[0]), strtolower($name));
     }
+
+    public function toArray(): array
+    {
+        return $this->headers;
+    }
+
+    private function getNameAsString(HeaderKey|string $name): string
+    {
+        return is_string($name) ? $name : $name->value;
+    }
+
+    /**
+     * Parses an array into the internal headers format.
+     * Handles both external format ['Header-Name' => 'value'] and internal format ['normalized-key' => ['Original-Name', ['values']]]
+     *
+     * @param array $headers Input array in either format
+     * @return array Internal headers format: ['normalized-key' => ['Original-Name', ['value1', 'value2']]]
+     */
+    private function parseFromArray(array $headers): array
+    {
+        if (empty($headers)) {
+            return [];
+        }
+
+        // Check if this is already in internal format
+        if ($this->isInternalFormat($headers)) {
+            return $headers;
+        }
+
+        // Parse external format
+        $parsed = [];
+
+        foreach ($headers as $name => $value) {
+            if (!is_string($name)) {
+                throw new InvalidArgumentException('Header name must be a string');
+            }
+
+            $key = strtolower($name);
+            $original = $this->normalizeName($name);
+
+            if (is_string($value)) {
+                $parsed[$key] = [$original, [$value]];
+            } elseif (is_array($value)) {
+                // Alle Werte als Strings validieren
+                foreach ($value as $val) {
+                    if (!is_string($val)) {
+                        throw new InvalidArgumentException('All header values must be strings: ' . print_r($headers, true));
+                    }
+                }
+                $parsed[$key] = [$original, array_values($value)];
+            } else {
+                throw new InvalidArgumentException('Header value must be a string or array of strings');
+            }
+        }
+
+        return $parsed;
+    }
+
+    /**
+     * Checks if the array is already in internal format
+     * Internal format: ['normalized-key' => ['Original-Name', ['value1', 'value2']]]
+     */
+    private function isInternalFormat(array $headers): bool
+    {
+        if (empty($headers)) {
+            return true;
+        }
+
+        // Check the first entry to determine the format
+        $firstValue = reset($headers);
+
+        // Internal format has array values with exactly 2 elements: [string, array]
+        return is_array($firstValue) &&
+               count($firstValue) === 2 &&
+               is_string($firstValue[0]) &&
+               is_array($firstValue[1]);
+    }
 }
diff --git a/src/Framework/Http/HttpMiddleware.php b/src/Framework/Http/HttpMiddleware.php
new file mode 100644
index 00000000..b31019eb
--- /dev/null
+++ b/src/Framework/Http/HttpMiddleware.php
@@ -0,0 +1,16 @@
+<?php
+
+namespace App\Framework\Http;
+
+interface HttpMiddleware
+{
+    /**
+     * Verarbeitet den Middleware-Kontext und ruft den nächsten Handler in der Kette auf.
+     *
+     * @param MiddlewareContext $context Der Middleware-Kontext mit Request und optionaler Response
+     * @param callable $next Der nächste Handler in der Kette
+     * @param RequestStateManager $stateManager
+     * @return MiddlewareContext Der aktualisierte Kontext
+     */
+    public function __invoke(MiddlewareContext $context, callable $next, RequestStateManager $stateManager): MiddlewareContext;
+}
diff --git a/src/Framework/Http/HttpMiddlewareChain.php b/src/Framework/Http/HttpMiddlewareChain.php
new file mode 100644
index 00000000..0a8e55d3
--- /dev/null
+++ b/src/Framework/Http/HttpMiddlewareChain.php
@@ -0,0 +1,181 @@
+<?php
+
+namespace App\Framework\Http;
+
+use App\Framework\DI\Container;
+use App\Framework\Logging\DefaultLogger;
+use App\Framework\Logging\Logger;
+use Closure;
+
+final readonly class HttpMiddlewareChain implements HttpMiddlewareNext
+{
+    private MiddlewareInvoker $invoker;
+    private DefaultLogger $logger;
+    private RequestStateManager $stateManager;
+
+    public function __construct(
+        private array     $middlewares,
+        private Closure   $fallbackHandler,
+        private Container $container
+    ) {
+        $this->invoker = new MiddlewareInvoker($this->container);
+        $this->logger = $this->container->get(Logger::class);
+    }
+
+    public function handle(Request $request): Response
+    {
+        // Kontext mit dem Request erstellen
+        $context = new MiddlewareContext($request);
+
+        $this->stateManager = new MiddlewareStateManager()->forRequest($request);
+
+        // Middleware-Stack durchlaufen
+        $resultContext = $this->processMiddlewareStack($context, 0);
+
+        // Am Ende die Response aus dem Kontext zurückgeben
+        if ($resultContext->hasResponse()) {
+            return $resultContext->response;
+        }
+
+        // Warnung über fehlende Response
+        $this->logger->warning('Keine Response nach Middleware-Chain - verwende Fallback-Handler', [
+            'uri' => $resultContext->request->path,
+            'method' => $resultContext->request->method->value,
+            'middleware_count' => count($this->middlewares),
+        ]);
+
+        // Fallback-Handler aufrufen
+        $response = ($this->fallbackHandler)($resultContext->request);
+
+        if (!$response instanceof Response) {
+            throw new \RuntimeException(sprintf(
+                'Fallback-Handler hat keine Response zurückgegeben, sondern %s',
+                is_object($response) ? get_class($response) : gettype($response)
+            ));
+        }
+
+        return $response;
+    }
+
+    private function processMiddlewareStack(MiddlewareContext $context, int $index): MiddlewareContext
+    {
+        // Wenn das Ende der Middleware-Kette erreicht ist
+        if ($index >= count($this->middlewares)) {
+            $this->logDebug("Ende der Middleware-Kette erreicht", $context, $index);
+            return $context;
+        }
+
+        $middleware = $this->middlewares[$index];
+        $middlewareName = $this->getMiddlewareName($middleware);
+
+        // Status VOR der Middleware loggen
+        $this->logDebug("VOR Middleware #{$index} ({$middlewareName})", $context, $index);
+
+        // Next-Funktion erstellen, die zur nächsten Middleware weiterleitet
+        $next = function (MiddlewareContext $nextContext) use ($index, $middlewareName) {
+            // Status beim Aufruf von $next() loggen
+            $this->logDebug("NEXT aufgerufen in #{$index} ({$middlewareName})", $nextContext, $index);
+
+            // Zur nächsten Middleware weitergehen
+            $resultContext = $this->processMiddlewareStack($nextContext, $index + 1);
+
+            // Status beim Rückgabewert von $next() loggen
+            $this->logDebug("NEXT Rückgabe an #{$index} ({$middlewareName})", $resultContext, $index);
+
+            // Detaillierte Prüfung auf verlorene Response
+            if ($nextContext->hasResponse() && !$resultContext->hasResponse()) {
+                $this->logError("RESPONSE VERLOREN zwischen Middleware #{$index} ({$middlewareName}) und nachfolgenden Middlewares!");
+            }
+
+            return $resultContext;
+        };
+
+        // Middleware mit dem Invoker ausführen
+        $resultContext = $this->invoker->invoke($middleware, $context, $next, $this->stateManager);
+
+        // Status NACH der Middleware loggen
+        $this->logDebug("NACH Middleware #{$index} ({$middlewareName})", $resultContext, $index);
+
+        /*
+        // Prüfung ob diese Middleware eine Response hinzugefügt oder entfernt hat
+        if (!$context->hasResponse() && $resultContext->hasResponse()) {
+            $this->logInfo("✅ Response ERSTELLT von Middleware #{$index} ({$middlewareName})", [
+                'middleware_name' => $middlewareName,
+                'middleware_index' => $index,
+                'response_status' => $resultContext->response?->status,
+            ]);
+        } elseif ($context->hasResponse() && !$resultContext->hasResponse()) {
+            $this->logError("❌ Response ENTFERNT von Middleware #{$index} ({$middlewareName})!", [
+                'middleware_name' => $middlewareName,
+                'middleware_index' => $index,
+                'original_response_status' => $context->response?->status,
+            ]);
+        }
+        */
+
+
+        return $resultContext;
+    }
+
+    /**
+     * Ermittelt einen lesbaren Namen für die Middleware
+     */
+    private function getMiddlewareName(mixed $middleware): string
+    {
+        if (is_string($middleware)) {
+            return $middleware;
+        }
+
+        if (is_object($middleware)) {
+            $className = get_class($middleware);
+            return substr($className, strrpos($className, '\\') + 1);
+        }
+
+        return gettype($middleware);
+    }
+
+    /**
+     * Debug-Logging mit Context-Informationen
+     */
+    private function logDebug(string $message, MiddlewareContext $context, int $index): void
+    {
+        $responseStatus = $context->hasResponse() ?
+            "Response✅ (Status: " . ($context->response->statusCode ?? 'unknown') . ")" :
+            "Response❌";
+
+        /*
+        $this->logger->debug('Middleware Chain: {message}', [
+            'message' => $message,
+            'response_status' => $responseStatus,
+            'uri' => $context->request->uri ?? 'unknown',
+            'method' => $context->request->method->value ?? 'unknown',
+            'middleware_index' => $index,
+            'has_response' => $context->hasResponse(),
+            'response_code' => $context->response?->status->value,
+        ]);
+        */
+    }
+
+    /**
+     * Info-Logging für wichtige Events
+     */
+    private function logInfo(string $message, array $context = []): void
+    {
+        $this->logger->info('Middleware Chain: {message}', array_merge([
+            'message' => $message,
+            'component' => 'MiddlewareChain'
+        ], $context));
+    }
+
+    /**
+     * Error-Logging für Probleme
+     */
+    private function logError(string $message, array $context = []): void
+    {
+        $this->logger->error('Middleware Chain ERROR: {message}', array_merge([
+            'message' => $message,
+            'component' => 'MiddlewareChain',
+            'stack_trace' => debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS, 5)
+        ], $context));
+    }
+}
diff --git a/src/Framework/Http/HttpMiddlewareNext.php b/src/Framework/Http/HttpMiddlewareNext.php
new file mode 100644
index 00000000..2b173de4
--- /dev/null
+++ b/src/Framework/Http/HttpMiddlewareNext.php
@@ -0,0 +1,8 @@
+<?php
+
+namespace App\Framework\Http;
+
+interface HttpMiddlewareNext
+{
+    public function handle(HttpRequest $request): Response;
+}
diff --git a/src/Framework/Http/HttpRequest.php b/src/Framework/Http/HttpRequest.php
index 22051fa8..da8d3044 100644
--- a/src/Framework/Http/HttpRequest.php
+++ b/src/Framework/Http/HttpRequest.php
@@ -4,15 +4,30 @@ declare(strict_types=1);
 
 namespace App\Framework\Http;
 
-final class HttpRequest implements Request
+use App\Framework\Http\Cookies\Cookies;
+
+final readonly class HttpRequest implements Request
 {
+    #public array $parsedBody;
+
     public function __construct(
-        public readonly HttpMethod $method = HttpMethod::GET,
-        readonly Headers $headers = new Headers(),
-        readonly string $body = '',
-        readonly string $path = '',
-        readonly array $files = [],
-        readonly Cookies $cookies = new Cookies()
+        public Method            $method = Method::GET,
+        public Headers           $headers = new Headers(),
+        public string            $body = '',
+        public string            $path = '',
+        public array             $queryParams = [],
+        public UploadedFiles     $files = new UploadedFiles([]),
+        public Cookies           $cookies = new Cookies(),
+        public ServerEnvironment $server = new ServerEnvironment(),
+        public RequestId         $id = new RequestId(),
+        public RequestBody       $parsedBody = new RequestBody(Method::GET, new Headers(), '', [])
     ) {
+        #$this->parsedBody = new RequestBodyParser()->parse($this);
+    }
+
+    // Hilfsmethode zum Abrufen von Query-Parametern
+    public function getQuery(string $key, mixed $default = null): mixed
+    {
+        return $this->queryParams[$key] ?? $default;
     }
 }
diff --git a/src/Framework/Http/HttpResponse.php b/src/Framework/Http/HttpResponse.php
index a016efbc..85de30ed 100644
--- a/src/Framework/Http/HttpResponse.php
+++ b/src/Framework/Http/HttpResponse.php
@@ -10,11 +10,5 @@ final readonly class HttpResponse implements Response
         public Status  $status = Status::OK,
         public Headers $headers = new Headers(),
         public string  $body = ''
-
-        /*public private(set) string $body = '' {
-            get => $this->body;
-            set => $value;
-        }*/
-    ) {
-    }
+    ) {}
 }
diff --git a/src/Framework/Http/IpAddress.php b/src/Framework/Http/IpAddress.php
new file mode 100644
index 00000000..4da0cdd3
--- /dev/null
+++ b/src/Framework/Http/IpAddress.php
@@ -0,0 +1,27 @@
+<?php
+
+namespace App\Framework\Http;
+
+/**
+ * Value Object für IP-Adressen
+ */
+final readonly class IpAddress
+{
+    public function __construct(
+        public string $value
+    ) {
+        if (!filter_var($value, FILTER_VALIDATE_IP)) {
+            throw new \InvalidArgumentException("Invalid IP address: {$value}");
+        }
+    }
+
+    public function isPrivate(): bool
+    {
+        return !filter_var($this->value, FILTER_VALIDATE_IP, FILTER_FLAG_NO_PRIV_RANGE);
+    }
+
+    public function __toString(): string
+    {
+        return $this->value;
+    }
+}
diff --git a/src/Framework/Http/HttpMethod.php b/src/Framework/Http/Method.php
similarity index 92%
rename from src/Framework/Http/HttpMethod.php
rename to src/Framework/Http/Method.php
index a04883c7..b683729b 100644
--- a/src/Framework/Http/HttpMethod.php
+++ b/src/Framework/Http/Method.php
@@ -4,7 +4,7 @@ declare(strict_types=1);
 
 namespace App\Framework\Http;
 
-enum HttpMethod: string
+enum Method: string
 {
     case GET = 'GET';
     case POST = 'POST';
@@ -15,5 +15,4 @@ enum HttpMethod: string
     case OPTIONS = 'OPTIONS';
     case TRACE = 'TRACE';
     case CONNECT = 'CONNECT';
-
 }
diff --git a/src/Framework/Http/Middleware/ServeStaticFilesMiddleware.php b/src/Framework/Http/Middleware/ServeStaticFilesMiddleware.php
new file mode 100644
index 00000000..d87f2bf8
--- /dev/null
+++ b/src/Framework/Http/Middleware/ServeStaticFilesMiddleware.php
@@ -0,0 +1,159 @@
+<?php
+
+namespace App\Framework\Http\Middleware;
+
+use App\Framework\Core\PathProvider;
+use App\Framework\Http\Headers;
+use App\Framework\Http\HttpResponse;
+use App\Framework\Http\Middleware;
+use App\Framework\Http\Request;
+use App\Framework\Http\Status;
+
+class ServeStaticFilesMiddleware implements Middleware
+{
+    private array $allowedExtensions = [
+        'jpg', 'jpeg', 'png', 'gif', 'webp', 'avif', 'svg',
+        'css', 'js', 'woff', 'woff2', 'ttf', 'eot',
+        'pdf', 'ico', 'xml', 'json'
+    ];
+
+    private array $mimeTypes = [
+        'jpg' => 'image/jpeg',
+        'jpeg' => 'image/jpeg',
+        'png' => 'image/png',
+        'gif' => 'image/gif',
+        'webp' => 'image/webp',
+        'avif' => 'image/avif',
+        'svg' => 'image/svg+xml',
+        'css' => 'text/css',
+        'js' => 'application/javascript',
+        'woff' => 'font/woff',
+        'woff2' => 'font/woff2',
+        'ttf' => 'font/ttf',
+        'eot' => 'application/vnd.ms-fontobject',
+        'pdf' => 'application/pdf',
+        'ico' => 'image/x-icon',
+        'xml' => 'application/xml',
+        'json' => 'application/json'
+    ];
+
+    public function __construct(
+        private PathProvider $pathProvider,
+        private string $mediaPrefix = '/media'
+    ) {}
+
+    public function process(Request $request, callable $next): HttpResponse
+    {
+        $path = $request->getPath();
+
+        // Prüfen ob es sich um eine Media-Anfrage handelt
+        if (str_starts_with($path, $this->mediaPrefix)) {
+            $filePath = substr($path, strlen($this->mediaPrefix));
+            return $this->serveStaticFile($filePath);
+        }
+
+        return $next($request);
+    }
+
+    private function serveStaticFile(string $filePath): HttpResponse
+    {
+        // Pfad bereinigen (verhindert Directory Traversal Angriffe)
+        $filePath = $this->sanitizePath($filePath);
+
+        // Dateiendung prüfen
+        $extension = strtolower(pathinfo($filePath, PATHINFO_EXTENSION));
+        if (!in_array($extension, $this->allowedExtensions)) {
+            return $this->notFound();
+        }
+
+        // Vollständigen Dateipfad konstruieren
+        $fullPath = $this->pathProvider->resolvePath('storage' . $filePath);
+
+        // Prüfen ob Datei existiert
+        if (!file_exists($fullPath) || !is_file($fullPath)) {
+            return $this->notFound();
+        }
+
+        // MIME-Typ ermitteln
+        $mimeType = $this->mimeTypes[$extension] ?? 'application/octet-stream';
+
+        // Datei auslesen
+        $content = file_get_contents($fullPath);
+
+        // Cache-Control Header basierend auf Dateityp setzen
+        $cacheControl = $this->getCacheControlHeader($extension);
+
+        // ETag für Caching generieren
+        $etag = '"' . md5_file($fullPath) . '"';
+
+        // Last-Modified Header
+        $lastModified = gmdate('D, d M Y H:i:s', filemtime($fullPath)) . ' GMT';
+
+        // Headers zusammenstellen
+        $headers = new Headers([
+            'Content-Type' => $mimeType,
+            'Content-Length' => filesize($fullPath),
+            'Cache-Control' => $cacheControl,
+            'ETag' => $etag,
+            'Last-Modified' => $lastModified
+        ]);
+
+        return new HttpResponse(
+            Status::OK,
+            $headers,
+            $content
+        );
+    }
+
+    private function sanitizePath(string $path): string
+    {
+        // Doppelte Slashes entfernen
+        $path = preg_replace('#/+#', '/', $path);
+
+        // Führende/nachfolgende Slashes entfernen
+        $path = trim($path, '/');
+
+        // Sicherstellen, dass kein '..' enthalten ist (verhindert Directory Traversal)
+        $parts = [];
+        foreach (explode('/', $path) as $part) {
+            if ($part === '.') {
+                continue;
+            }
+
+            if ($part === '..') {
+                array_pop($parts);
+            } else {
+                $parts[] = $part;
+            }
+        }
+
+        return '/' . implode('/', $parts);
+    }
+
+    private function getCacheControlHeader(string $extension): string
+    {
+        // Bilder und Fonts können länger gecacht werden
+        $imageFontExtensions = ['jpg', 'jpeg', 'png', 'gif', 'webp', 'avif', 'svg', 'woff', 'woff2', 'ttf', 'eot'];
+
+        if (in_array($extension, $imageFontExtensions)) {
+            return 'public, max-age=31536000'; // 1 Jahr
+        }
+
+        // CSS und JS
+        if (in_array($extension, ['css', 'js'])) {
+            return 'public, max-age=604800'; // 1 Woche
+        }
+
+        // Sonstige Dateien
+        return 'public, max-age=86400'; // 1 Tag
+    }
+
+    private function notFound(): HttpResponse
+    {
+        return new HttpResponse(
+            Status::NOT_FOUND,
+            new Headers(['Content-Type' => 'text/plain']),
+            'Datei nicht gefunden'
+        );
+    }
+}
diff --git a/src/Framework/Http/MiddlewareContext.php b/src/Framework/Http/MiddlewareContext.php
new file mode 100644
index 00000000..e4592dc1
--- /dev/null
+++ b/src/Framework/Http/MiddlewareContext.php
@@ -0,0 +1,32 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Http;
+
+/**
+ * Kontextobjekt, das durch die Middleware-Kette weitergegeben wird.
+ * Es enthält sowohl den ursprünglichen Request als auch eine optionale Response.
+ */
+final readonly class MiddlewareContext
+{
+    public function __construct(
+        public Request   $request,
+        public ?Response $response = null,
+    ) {}
+
+    /**
+     * Erstellt einen neuen Kontext mit der gleichen Anfrage, aber einer anderen Antwort
+     */
+    public function withResponse(Response $response): self
+    {
+        return new self($this->request, $response);
+    }
+
+    /**
+     * Prüft, ob bereits eine Response im Kontext vorhanden ist
+     */
+    public function hasResponse(): bool
+    {
+        return $this->response !== null;
+    }
+}
diff --git a/src/Framework/Http/MiddlewareInvoker.php b/src/Framework/Http/MiddlewareInvoker.php
new file mode 100644
index 00000000..ee3d38ef
--- /dev/null
+++ b/src/Framework/Http/MiddlewareInvoker.php
@@ -0,0 +1,65 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Http;
+
+use App\Framework\DI\Container;
+use App\Framework\Logging\DefaultLogger;
+
+final readonly class MiddlewareInvoker
+{
+    private DefaultLogger $logger;
+
+    public function __construct(
+        private Container $container
+    ) {
+        $this->logger = $this->container->get(DefaultLogger::class);
+    }
+
+    /**
+     * Führt eine einzelne Middleware aus und gibt den resultierenden Kontext zurück
+     */
+    public function invoke(
+        HttpMiddleware|string $middleware,
+        MiddlewareContext $context,
+        callable $next,
+        RequestStateManager $stateManager
+    ): MiddlewareContext {
+        // Middleware-Instanz holen, falls ein Klassenname übergeben wurde
+        if (is_string($middleware)) {
+            $middleware = $this->container->get($middleware);
+        }
+
+        // Debug-Ausgabe vor der Ausführung
+        $this->logger->debug('VOR: Middleware ' . get_class($middleware) .
+            ' - hasResponse: ' . ($context->hasResponse() ? 'ja' : 'nein'));
+
+        try {
+            // Middleware ausführen
+            /* @var $middleware HttpMiddleware */
+            $resultContext = $middleware($context, $next, $stateManager);
+
+            // Typüberprüfung
+            if (!$resultContext instanceof MiddlewareContext) {
+                throw new \RuntimeException(sprintf(
+                    'Middleware %s hat keinen MiddlewareContext zurückgegeben, sondern %s',
+                    get_class($middleware),
+                    is_object($resultContext) ? get_class($resultContext) : gettype($resultContext)
+                ));
+            }
+
+            // Debug-Ausgabe nach der Ausführung
+            $this->logger->debug('NACH: Middleware ' . get_class($middleware) .
+                ' - hasResponse: ' . ($resultContext->hasResponse() ? 'ja' : 'nein'));
+
+            return $resultContext;
+        } catch (\Throwable $e) {
+            $this->logger->error('Fehler in Middleware ' . get_class($middleware) . ': ' . $e->getMessage());
+
+            throw $e;
+
+            // Bei Fehler den ursprünglichen Kontext zurückgeben
+            return $context;
+        }
+    }
+}
diff --git a/src/Framework/Http/MiddlewareManager.php b/src/Framework/Http/MiddlewareManager.php
new file mode 100644
index 00000000..cccc01f0
--- /dev/null
+++ b/src/Framework/Http/MiddlewareManager.php
@@ -0,0 +1,124 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Http;
+
+use App\Framework\Core\InterfaceImplementationLocator;
+use App\Framework\DI\Container;
+use App\Framework\Discovery\Results\DiscoveryResults;
+use App\Framework\Http\HttpMiddleware;
+use App\Framework\Http\Middlewares\ControllerRequestMiddleware;
+use App\Framework\Http\Middlewares\RoutingMiddleware;
+use App\Framework\Validation\ValidationErrorMiddleware;
+
+/**
+ * Verwaltet die HTTP-Middleware-Pipeline
+ */
+final readonly class MiddlewareManager
+{
+    /**
+     * @var array<string> Array mit Middleware-Klassen
+     */
+    #private array $middlewares = [];
+
+    public HttpMiddlewareChain $chain;
+
+    public function __construct(
+        private Container        $container,
+        private DiscoveryResults $discoveryResults,
+    )
+    {
+        // Standard-Middlewares registrieren
+        /*$this->middlewares = [
+            ControllerRequestMiddleware::class,
+            ValidationErrorMiddleware::class,
+            RoutingMiddleware::class
+        ];*/
+
+        $middlewares = $this->buildMiddlewareStack();
+
+        foreach($middlewares as $middleware) {
+            #echo $middleware . " " . $this->getMiddlewarePriority($middleware) . "<br>". PHP_EOL;
+        }
+
+
+        $this->chain = new HttpMiddlewareChain(
+            $middlewares,
+            fn() => new HttpResponse(Status::NOT_FOUND),
+            $this->container
+        );
+    }
+
+    private function buildMiddlewareStack(): array
+    {
+        $middlewares = $this->discoveryResults->get(HttpMiddleware::class);
+        $middlewares = array_column($middlewares, 'class');
+        return $this->sortMiddlewaresByPriority($middlewares);
+    }
+
+    /**
+     * Erstellt eine Middleware-Chain mit den registrierten Middlewares
+     */
+    /*public function createMiddlewareChain(callable $fallbackHandler): HttpMiddlewareChain
+    {
+        return new HttpMiddlewareChain(
+            $this->middlewares,
+            $fallbackHandler,
+            $this->container
+        );
+    }*/
+
+    public static function getPriority(object|string $middlewareClass): int
+    {
+        $reflection = new \ReflectionClass($middlewareClass);
+        $attrs = $reflection->getAttributes(MiddlewarePriorityAttribute::class);
+        if ($attrs) {
+            /** @var MiddlewarePriorityAttribute $attr */
+            $attr = $attrs[0]->newInstance();
+            if ($attr->offset !== 0) {
+                return $attr->priority->value + $attr->offset;
+            }
+            return $attr->priority->value;
+        }
+        // Standard-Priorität (oder Fehlermeldung)
+        return MiddlewarePriority::BUSINESS_LOGIC->value;
+    }
+
+    // Methode zum Sortieren der Middleware nach Priorität
+    private function sortMiddlewaresByPriority($middlewares): array
+    {
+        usort($middlewares, function (object|string $a, object|string $b) {
+            $priorityA = $this->getMiddlewarePriority($a);
+            $priorityB = $this->getMiddlewarePriority($b);
+
+            return $priorityB <=> $priorityA; // Höhere Priorität zuerst
+        });
+
+        return $middlewares;
+    }
+
+    // Hilfsmethode zum Abrufen der Middleware-Priorität
+    private function getMiddlewarePriority(object|string $middlewareClass): int
+    {
+        $priority = $this->discoveryResults->get(MiddlewarePriorityAttribute::class);
+        $middlewareClass = ltrim($middlewareClass, '\\');
+
+        foreach($priority as $item) {
+            #dd($middlewareClass);
+            if ($item['class'] === $middlewareClass) {
+                #debug($item['attribute_data']['priority']);
+                #dd($item['attribute_data']['priority']->value);
+                $priority = $item['attribute_data']['priority'];
+                if(!is_int($priority)) {
+                    $priority = $priority->value;
+                }
+
+                return $priority + ($item['attribute_data']['offset'] ?? 0);
+            }
+        }
+
+        // Middleware has no Priority: Set to default
+        return MiddlewarePriority::BUSINESS_LOGIC->value;
+    }
+}
diff --git a/src/Framework/Http/MiddlewarePriority.php b/src/Framework/Http/MiddlewarePriority.php
new file mode 100644
index 00000000..02347355
--- /dev/null
+++ b/src/Framework/Http/MiddlewarePriority.php
@@ -0,0 +1,58 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Http;
+
+use Attribute;
+
+#[\Attribute(Attribute::TARGET_CLASS)]
+enum MiddlewarePriority: int
+{
+    // Systemebene - wird vor allem anderen ausgeführt
+    case VERY_EARLY = 1100;  // Vor Error Handling, für Request-ID
+    case ERROR_HANDLING = 1000;
+    case SECURITY = 900;
+    case SESSION = 800;
+    case CORS = 700;
+
+    // Anwendungsebene
+    case ROUTING = 500;
+    case CONTENT_NEGOTIATION = 400;
+    case AUTHENTICATION = 300;
+    case AUTHORIZATION = 200;
+
+    // Geschäftslogik
+    case BUSINESS_LOGIC = 100;
+
+    // Logging und Monitoring - wird nach allem anderen ausgeführt
+    case LOGGING = 0;
+
+    /**
+     * Hilfsmethode zum Erzeugen einer benutzerdefinierten Priorität
+     * innerhalb eines bestimmten Bereichs
+     */
+    /*public static function custom(self $baseLevel, int $offset = 0): int
+    {
+        return $baseLevel->value + $offset;
+    }*/
+
+    /**
+     * Gibt eine lesbare Beschreibung der Priorität zurück
+     */
+    public function getDescription(): string
+    {
+        return match($this) {
+            self::VERY_EARLY => 'Sehr frühe Ausführung (Request-ID)',
+            self::ERROR_HANDLING => 'Fehlerbehandlung',
+            self::SECURITY => 'Sicherheit (Firewall, CSRF)',
+            self::SESSION => 'Session-Verwaltung',
+            self::CORS => 'CORS-Header',
+            self::ROUTING => 'Routing und URL-Rewriting',
+            self::CONTENT_NEGOTIATION => 'Content-Negotiation',
+            self::AUTHENTICATION => 'Authentifizierung',
+            self::AUTHORIZATION => 'Autorisierung',
+            self::BUSINESS_LOGIC => 'Geschäftslogik',
+            self::LOGGING => 'Logging (späteste Ausführung)',
+        };
+    }
+}
diff --git a/src/Framework/Http/MiddlewarePriorityAttribute.php b/src/Framework/Http/MiddlewarePriorityAttribute.php
new file mode 100644
index 00000000..5f14c48a
--- /dev/null
+++ b/src/Framework/Http/MiddlewarePriorityAttribute.php
@@ -0,0 +1,15 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Http;
+
+use Attribute;
+
+#[Attribute(Attribute::TARGET_CLASS)]
+class MiddlewarePriorityAttribute
+{
+    public function __construct(
+        public MiddlewarePriority $priority,
+        public int $offset = 0
+    ) {}
+}
diff --git a/src/Framework/Http/MiddlewareStateManager.php b/src/Framework/Http/MiddlewareStateManager.php
new file mode 100644
index 00000000..8c80d23f
--- /dev/null
+++ b/src/Framework/Http/MiddlewareStateManager.php
@@ -0,0 +1,20 @@
+<?php
+
+namespace App\Framework\Http;
+
+use WeakMap;
+
+class MiddlewareStateManager
+{
+    private Weakmap $requestStates;
+
+    public function __construct()
+    {
+        $this->requestStates = new WeakMap();
+    }
+
+    public function forRequest(Request $request): RequestStateManager
+    {
+        return new RequestStateManager($this->requestStates, $request);
+    }
+}
diff --git a/src/Framework/Http/Middlewares/AuthMiddleware.php b/src/Framework/Http/Middlewares/AuthMiddleware.php
new file mode 100644
index 00000000..2bc8535b
--- /dev/null
+++ b/src/Framework/Http/Middlewares/AuthMiddleware.php
@@ -0,0 +1,25 @@
+<?php
+
+namespace App\Framework\Http\Middlewares;
+
+use App\Framework\Http\HttpMiddleware;
+use App\Framework\Http\HttpResponse;
+use App\Framework\Http\MiddlewareContext;
+use App\Framework\Http\MiddlewarePriority;
+use App\Framework\Http\MiddlewarePriorityAttribute;
+use App\Framework\Http\RequestStateManager;
+use App\Framework\Http\Request;
+use App\Framework\Http\Status;
+
+#[MiddlewarePriorityAttribute(MiddlewarePriority::AUTHENTICATION)]
+final readonly class AuthMiddleware implements HttpMiddleware
+{
+    public function __invoke(MiddlewareContext $context, callable $next, RequestStateManager $stateManager): MiddlewareContext
+    {
+        /*if (str_starts_with($context->request->path, '/admin')) {
+            return new HttpResponse(Status::FORBIDDEN, body: 'Zugriff verweigert');
+        }*/
+
+        return $next($context);
+    }
+}
diff --git a/src/Framework/Http/Middlewares/CORSMiddleware.php b/src/Framework/Http/Middlewares/CORSMiddleware.php
new file mode 100644
index 00000000..87688806
--- /dev/null
+++ b/src/Framework/Http/Middlewares/CORSMiddleware.php
@@ -0,0 +1,53 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Http\Middlewares;
+
+use App\Framework\Http\HttpMiddleware;
+use App\Framework\Http\MiddlewareContext;
+use App\Framework\Http\MiddlewarePriority;
+use App\Framework\Http\MiddlewarePriorityAttribute;
+use App\Framework\Http\RequestStateManager;
+use App\Framework\Http\Request;
+use App\Framework\Http\Response;
+use App\Framework\Http\ResponseManipulator;
+
+#[MiddlewarePriorityAttribute(MiddlewarePriority::CORS)]
+final readonly class CORSMiddleware implements HttpMiddleware
+{
+    public function __construct(
+        private ResponseManipulator $manipulator
+    ) {}
+
+    public function __invoke(MiddlewareContext $context, callable $next, RequestStateManager $stateManager): MiddlewareContext
+    {
+        // Debug-Ausgabe vor der Verarbeitung
+        #var_dump('CORS Middleware Start - Kontext hat Response: ' . ($context->hasResponse() ? 'ja' : 'nein'));
+
+        // Nächste Middleware aufrufen UND den Kontext mit der Response behalten
+        $resultContext = $next($context);
+
+        // Debug-Ausgabe nach der Verarbeitung
+        #var_dump('CORS Middleware End - Kontext hat Response: ' . ($resultContext->hasResponse() ? 'ja' : 'nein'));
+
+        // Wenn eine Response vorhanden ist, CORS-Header hinzufügen
+        if ($resultContext->hasResponse()) {
+            $response = $resultContext->response;
+
+            // Aktualisierte Headers erstellen
+            $updatedHeaders = $response->headers->with('Access-Control-Allow-Origin', '*');
+            $updatedHeaders = $updatedHeaders->with('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS');
+            $updatedHeaders = $updatedHeaders->with('Access-Control-Allow-Headers', 'Content-Type, Authorization');
+
+            // Neue Response mit aktualisierten Headers erstellen
+            $updatedResponse = $this->manipulator->withHeaders($response, $updatedHeaders);
+
+            // Kontext mit der aktualisierten Response zurückgeben
+            return $resultContext->withResponse($updatedResponse);
+        }
+
+        // Wenn keine Response vorhanden ist, Kontext unverändert zurückgeben
+        return $resultContext;
+
+    }
+}
diff --git a/src/Framework/Http/Middlewares/ControllerRequestMiddleware.php b/src/Framework/Http/Middlewares/ControllerRequestMiddleware.php
new file mode 100644
index 00000000..356195b9
--- /dev/null
+++ b/src/Framework/Http/Middlewares/ControllerRequestMiddleware.php
@@ -0,0 +1,29 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Http\Middlewares;
+
+use App\Framework\DI\DefaultContainer;
+use App\Framework\Http\HttpMiddleware;
+use App\Framework\Http\MiddlewareContext;
+use App\Framework\Http\RequestStateManager;
+use App\Framework\Http\Request;
+use App\Framework\Http\Response;
+
+final readonly class ControllerRequestMiddleware implements HttpMiddleware
+{
+    public function __construct(
+        #private Container $container
+    ) {}
+
+    /**
+     * @param RequestStateManager $stateManager
+     * @inheritDoc
+     */
+    public function __invoke(MiddlewareContext $context, callable $next, RequestStateManager $stateManager): MiddlewareContext
+    {
+
+
+        return $next($context);
+    }
+}
diff --git a/src/Framework/Http/Middlewares/CsrfMiddleware.php b/src/Framework/Http/Middlewares/CsrfMiddleware.php
new file mode 100644
index 00000000..4908ff1f
--- /dev/null
+++ b/src/Framework/Http/Middlewares/CsrfMiddleware.php
@@ -0,0 +1,47 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Http\Middlewares;
+
+use App\Framework\Http\HttpMiddleware;
+use App\Framework\Http\Method;
+use App\Framework\Http\MiddlewareContext;
+use App\Framework\Http\MiddlewarePriority;
+use App\Framework\Http\MiddlewarePriorityAttribute;
+use App\Framework\Http\RequestStateManager;
+use App\Framework\Http\Session\Session;
+
+#[MiddlewarePriorityAttribute(MiddlewarePriority::SECURITY, -150)] // Push after Session Creation
+final readonly class CsrfMiddleware implements HttpMiddleware
+{
+    public function __construct(
+        private Session $session,
+    ){}
+
+    public function __invoke(MiddlewareContext $context, callable $next, RequestStateManager $stateManager): MiddlewareContext
+    {
+        $request = $context->request;
+
+        if (!$this->session->isStarted()) {
+            throw new \RuntimeException('Session must be started before CSRF validation');
+        }
+
+        if($request->method === Method::POST) {
+            // FormId ist jetzt immer vorhanden durch automatische Generierung
+            $formId = $request->parsedBody->get('_form_id');
+            $token = $request->parsedBody->get('_token');
+
+            if (!$formId || !$token) {
+                throw new \Exception('CSRF-Daten fehlen');
+            }
+
+            $valid = $this->session->csrf->validateToken($formId, $token);
+
+            if(!$valid) {
+                throw new \Exception('CSRF-Token ungültig');
+            }
+        }
+
+        return $next($context);
+    }
+}
diff --git a/src/Framework/Http/Middlewares/ExceptionHandlingMiddleware.php b/src/Framework/Http/Middlewares/ExceptionHandlingMiddleware.php
new file mode 100644
index 00000000..3a3b813d
--- /dev/null
+++ b/src/Framework/Http/Middlewares/ExceptionHandlingMiddleware.php
@@ -0,0 +1,72 @@
+<?php
+
+namespace App\Framework\Http\Middlewares;
+
+use App\Framework\ErrorHandling\ErrorHandler;
+use App\Framework\ErrorHandling\ExceptionConverter;
+use App\Framework\Http\HttpMiddleware;
+use App\Framework\Http\HttpResponse;
+use App\Framework\Http\MiddlewareContext;
+use App\Framework\Http\MiddlewarePriority;
+use App\Framework\Http\MiddlewarePriorityAttribute;
+use App\Framework\Http\RequestStateManager;
+use App\Framework\Http\RequestIdGenerator;
+use App\Framework\Logging\DefaultLogger;
+use App\Framework\Validation\Exceptions\ValidationException;
+
+#[MiddlewarePriorityAttribute(MiddlewarePriority::ERROR_HANDLING)]
+final readonly class ExceptionHandlingMiddleware implements HttpMiddleware
+{
+    public function __construct(
+        private DefaultLogger      $logger,
+        private RequestIdGenerator $requestIdGenerator,
+        private ErrorHandler $errorHandler,
+    ) {}
+
+    public function __invoke(MiddlewareContext $context, callable $next, RequestStateManager $stateManager): MiddlewareContext
+    {
+        try {
+            return $next($context);
+        } catch (ValidationException $e) {
+            throw $e;
+        } catch (\Throwable $e) {
+
+            $response = $this->errorHandler->createHttpResponse($e, $context);
+
+            return $context->withResponse($response);
+
+
+
+
+            // Detaillierte Fehlerinformationen loggen
+            $this->logger->error('Unbehandelte Exception in Middleware-Chain', [
+                'exception' => $e,
+                'path' => $context->request->path,
+                'method' => $context->request->method->value,
+            ]);
+
+            // Request-ID für die Antwort holen
+            $requestId = $this->requestIdGenerator->generate();
+
+            // Passende HTTP-Response basierend auf der Exception
+            $status = ExceptionConverter::getStatusFromException($e);
+
+            // Debug-Modus prüfen
+            $isDebug = filter_var($_ENV['APP_DEBUG'] ?? false, FILTER_VALIDATE_BOOLEAN);
+
+            // Response-Body erstellen
+            $body = ExceptionConverter::getResponseBody(
+                $e,
+                $isDebug,
+                $requestId->getId()
+            );
+
+            $response = new HttpResponse(
+                status: $status,
+                body: json_encode($body, JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE)
+            );
+
+            return $context->withResponse($response);
+        }
+    }
+}
diff --git a/src/Framework/Http/Middlewares/HoneypotMiddleware.php b/src/Framework/Http/Middlewares/HoneypotMiddleware.php
new file mode 100644
index 00000000..c56b264b
--- /dev/null
+++ b/src/Framework/Http/Middlewares/HoneypotMiddleware.php
@@ -0,0 +1,75 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Http\Middlewares;
+
+use App\Framework\Http\HttpMiddleware;
+use App\Framework\Http\Method;
+use App\Framework\Http\MiddlewareContext;
+use App\Framework\Http\MiddlewarePriority;
+use App\Framework\Http\MiddlewarePriorityAttribute;
+use App\Framework\Http\RequestStateManager;
+use Psr\Log\LoggerInterface;
+
+#[MiddlewarePriorityAttribute(MiddlewarePriority::SECURITY, -140)] // Nach CSRF, vor anderen Validierungen
+final readonly class HoneypotMiddleware implements HttpMiddleware
+{
+    public function __construct(
+        private ?LoggerInterface $logger = null
+    ) {}
+
+    public function __invoke(MiddlewareContext $context, callable $next, RequestStateManager $stateManager): MiddlewareContext
+    {
+        $request = $context->request;
+
+        if ($request->method === Method::POST) {
+            $this->validateHoneypot($request);
+        }
+
+        return $next($context);
+    }
+
+    private function validateHoneypot($request): void
+    {
+        $honeypotName = $request->parsedBody->get('_honeypot_name');
+
+        if (!$honeypotName) {
+            $this->logSuspiciousActivity('Missing honeypot name', $request);
+            throw new \Exception('Spam-Schutz ausgelöst');
+        }
+
+        $honeypotValue = $request->parsedBody->get($honeypotName);
+
+        // Honeypot wurde ausgefüllt = Bot erkannt
+        if (!empty($honeypotValue)) {
+            $this->logSuspiciousActivity("Honeypot filled: {$honeypotName} = {$honeypotValue}", $request);
+            throw new \Exception('Spam-Schutz ausgelöst');
+        }
+
+        // Zusätzliche Zeit-basierte Validierung (optional)
+        $this->validateSubmissionTime($request);
+    }
+
+    private function validateSubmissionTime($request): void
+    {
+        // Formulare, die zu schnell abgeschickt werden, sind verdächtig
+        $startTime = $request->parsedBody->get('_form_start_time');
+
+        if ($startTime && (time() - (int)$startTime) < 2) {
+            $this->logSuspiciousActivity('Form submitted too quickly', $request);
+            throw new \Exception('Spam-Schutz ausgelöst');
+        }
+    }
+
+    private function logSuspiciousActivity(string $reason, $request): void
+    {
+        if ($this->logger) {
+            $this->logger->warning('Honeypot triggered', [
+                'reason' => $reason,
+                'ip' => $request->getClientIp(),
+                'user_agent' => $request->headers->get('User-Agent') ?? 'unknown',
+                'url' => $request->uri
+            ]);
+        }
+    }
+}
diff --git a/src/Framework/Http/Middlewares/LoggingMiddleware.php b/src/Framework/Http/Middlewares/LoggingMiddleware.php
new file mode 100644
index 00000000..ec823fe9
--- /dev/null
+++ b/src/Framework/Http/Middlewares/LoggingMiddleware.php
@@ -0,0 +1,56 @@
+<?php
+
+namespace App\Framework\Http\Middlewares;
+
+use App\Framework\Http\HttpMiddleware;
+use App\Framework\Http\MiddlewareContext;
+use App\Framework\Http\MiddlewarePriority;
+use App\Framework\Http\MiddlewarePriorityAttribute;
+use App\Framework\Http\RequestStateManager;
+use App\Framework\Logging\DefaultLogger;
+
+#[MiddlewarePriorityAttribute(MiddlewarePriority::LOGGING)]
+final readonly class LoggingMiddleware implements HttpMiddleware
+{
+    public function __construct(
+        private DefaultLogger $logger
+    ) {}
+
+    public function __invoke(MiddlewareContext $context, callable $next, RequestStateManager $stateManager): MiddlewareContext
+    {
+        $start = microtime(true);
+
+        // Request-Informationen loggen
+        $this->logger->info("HTTP Request", [
+            'path' => $context->request->path,
+            'method' => $context->request->method->value,
+            'query' => $context->request->queryParams,
+        ]);
+
+        // Nachfolgende Middlewares aufrufen
+        $resultContext = $next($context);
+
+        // Dauer berechnen
+        $duration = number_format((microtime(true) - $start) * 1000, 2);
+
+        // Status bestimmen
+        $status = $resultContext->hasResponse()
+            ? $resultContext->response->status->value
+            : 'keine Response';
+
+        // Response-Informationen loggen - Warnung bei Fehlercodes
+        if ($resultContext->hasResponse() && $resultContext->response->status->value >= 400) {
+            $this->logger->warning("HTTP Response", [
+                'status' => $status,
+                'duration_ms' => $duration,
+            ]);
+        } else {
+            $this->logger->info("HTTP Response", [
+                'status' => $status,
+                'duration_ms' => $duration,
+            ]);
+        }
+
+        return $resultContext;
+    }
+}
diff --git a/src/Framework/Http/Middlewares/RateLimitingMiddleware.php b/src/Framework/Http/Middlewares/RateLimitingMiddleware.php
new file mode 100644
index 00000000..383f9e38
--- /dev/null
+++ b/src/Framework/Http/Middlewares/RateLimitingMiddleware.php
@@ -0,0 +1,172 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Http\Middlewares;
+
+use App\Framework\Http\Headers;
+use App\Framework\Http\HttpMiddleware;
+use App\Framework\Http\HttpResponse;
+use App\Framework\Http\MiddlewareContext;
+use App\Framework\Http\MiddlewarePriority;
+use App\Framework\Http\MiddlewarePriorityAttribute;
+use App\Framework\Http\Request;
+use App\Framework\Http\Status;
+use Predis\Client as RedisClient;
+
+/**
+ * Middleware zum Schutz vor zu vielen Anfragen von einer IP-Adresse.
+ * Verwendet Redis zum Zählen der Anfragen und implementiert ein Sliding Window Limiting.
+ */
+#[MiddlewarePriorityAttribute(MiddlewarePriority::SECURITY)]
+final class RateLimitingMiddleware implements XHttpMiddleware
+{
+    private const string REDIS_KEY_PREFIX = 'rate_limit:';
+
+    /**
+     * @param RedisClient $redis Redis-Client zum Speichern der Zähler
+     * @param int $defaultLimit Standardmäßige Anzahl an erlaubten Anfragen im Zeitfenster
+     * @param int $windowSeconds Länge des Zeitfensters in Sekunden
+     * @param array<string, array{limit: int, window: int}> $pathLimits Spezifische Limits für bestimmte Pfade
+     */
+    public function __construct(
+        private readonly RedisClient $redis,
+        private readonly int $defaultLimit = 60,
+        private readonly int $windowSeconds = 60,
+        private readonly array $pathLimits = []
+    ) {
+    }
+
+    public function __invoke(MiddlewareContext $context, callable $next): MiddlewareContext
+    {
+        $clientIp = $this->getClientIp($context->request);
+        $path = $context->request->path;
+
+        // Limits für den aktuellen Pfad ermitteln
+        [$limit, $window] = $this->getLimitsForPath($path);
+
+        // Redis-Schlüssel für diese IP und diesen Pfad
+        $redisKey = $this->getRedisKey($clientIp, $path);
+
+        // Anfrage zählen und prüfen
+        $requestCount = $this->countRequest($redisKey, $window);
+
+        // Rate-Limiting-Header zur Antwort hinzufügen
+        $remaining = max(0, $limit - $requestCount);
+        $context = $context->withResponseHeader('X-RateLimit-Limit', (string)$limit)
+                           ->withResponseHeader('X-RateLimit-Remaining', (string)$remaining)
+                           ->withResponseHeader('X-RateLimit-Reset', (string)$this->redis->ttl($redisKey));
+
+        // Wenn das Limit überschritten wurde, 429-Antwort zurückgeben
+        if ($requestCount > $limit) {
+            $response = new HttpResponse(
+                Status::TOO_MANY_REQUESTS,
+                new Headers(['Content-Type' => 'application/json'])
+            );
+
+            // Retry-After Header hinzufügen
+            $retryAfter = $this->redis->ttl($redisKey);
+            $response = $response->withHeader('Retry-After', (string)$retryAfter);
+
+            // JSON-Antwort mit Fehlermeldung
+            $errorResponse = [
+                'error' => 'Zu viele Anfragen',
+                'message' => 'Sie haben das Limit für Anfragen überschritten. Bitte versuchen Sie es später erneut.',
+                'retry_after' => $retryAfter
+            ];
+
+            $response->getBody()->write(json_encode($errorResponse));
+
+            return $context->withResponse($response);
+        }
+
+        // Anfrage weiterleiten
+        return $next($context);
+    }
+
+    /**
+     * Zählt eine Anfrage und gibt die aktuelle Anzahl zurück.
+     *
+     * @param string $key Der Redis-Schlüssel für den Counter
+     * @param int $window Das Zeitfenster in Sekunden
+     * @return int Die aktuelle Anzahl an Anfragen im Zeitfenster
+     */
+    private function countRequest(string $key, int $window): int
+    {
+        // Aktuelle Zeit als Score (für Sorted Set)
+        $now = time();
+
+        // Alten Einträge entfernen (älter als das Zeitfenster)
+        $this->redis->zremrangebyscore($key, 0, $now - $window);
+
+        // Neue Anfrage hinzufügen
+        $this->redis->zadd($key, [$now => $now]);
+
+        // Gesamtanzahl der Anfragen im Zeitfenster ermitteln
+        $count = $this->redis->zcard($key);
+
+        // TTL für den Key setzen (Aufräumen)
+        $this->redis->expire($key, $window);
+
+        return (int)$count;
+    }
+
+    /**
+     * Ermittelt die Limits für einen bestimmten Pfad.
+     *
+     * @param string $path Der Pfad
+     * @return array{int, int} [limit, window]
+     */
+    private function getLimitsForPath(string $path): array
+    {
+        // Prüfen auf spezifische Pfad-Limits
+        foreach ($this->pathLimits as $pattern => $config) {
+            if (preg_match($pattern, $path)) {
+                return [$config['limit'], $config['window']];
+            }
+        }
+
+        // Standardwerte zurückgeben
+        return [$this->defaultLimit, $this->windowSeconds];
+    }
+
+    /**
+     * Generiert den Redis-Schlüssel für eine IP und einen Pfad.
+     */
+    private function getRedisKey(string $ip, string $path): string
+    {
+        // Für allgemeines Rate-Limiting alle Pfade gleich behandeln
+        if (empty($this->pathLimits)) {
+            return self::REDIS_KEY_PREFIX . $ip;
+        }
+
+        // Für pfad-spezifisches Rate-Limiting einen pfad-spezifischen Schlüssel erstellen
+        $pathHash = md5($path);
+        return self::REDIS_KEY_PREFIX . "{$ip}:{$pathHash}";
+    }
+
+    /**
+     * Ermittelt die IP-Adresse des Clients unter Berücksichtigung von Proxies.
+     */
+    private function getClientIp(Request $request): string
+    {
+        $headers = [
+            'X-Forwarded-For',
+            'X-Real-IP',
+            'HTTP_X_FORWARDED_FOR',
+            'HTTP_CLIENT_IP',
+            'REMOTE_ADDR'
+        ];
+
+        foreach ($headers as $header) {
+            $value = $request->headers->get($header)[0] ?? null;
+            if ($value) {
+                // Bei mehreren IPs (X-Forwarded-For kann mehrere enthalten) die erste nehmen
+                $ips = explode(',', $value);
+                return trim($ips[0]);
+            }
+        }
+
+        return '0.0.0.0';
+    }
+}
diff --git a/src/Framework/Http/Middlewares/RemovePoweredByMiddleware.php b/src/Framework/Http/Middlewares/RemovePoweredByMiddleware.php
new file mode 100644
index 00000000..5142c0e7
--- /dev/null
+++ b/src/Framework/Http/Middlewares/RemovePoweredByMiddleware.php
@@ -0,0 +1,46 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Http\Middlewares;
+
+use App\Framework\Http\HttpMiddleware;
+use App\Framework\Http\MiddlewareContext;
+use App\Framework\Http\MiddlewarePriority;
+use App\Framework\Http\MiddlewarePriorityAttribute;
+use App\Framework\Http\RequestStateManager;
+use App\Framework\Http\ResponseManipulator;
+
+#[MiddlewarePriorityAttribute(MiddlewarePriority::SECURITY)]
+final readonly class RemovePoweredByMiddleware implements HttpMiddleware
+{
+    public function __construct(
+        private ResponseManipulator $manipulator
+    ) {}
+
+    public function __invoke(MiddlewareContext $context, callable $next, RequestStateManager $stateManager): MiddlewareContext
+    {
+        // Nächste Middleware aufrufen
+        $resultContext = $next($context);
+
+
+        // Wenn eine Response vorhanden ist, X-Powered-By Header entfernen
+        if ($resultContext->hasResponse()) {
+
+            $response = $resultContext->response;
+            $updatedHeaders = $response->headers;
+
+            // X-Powered-By Header entfernen, falls vorhanden
+            if ($updatedHeaders->has('X-Powered-By')) {
+                $updatedHeaders = $updatedHeaders->without('X-Powered-By');
+
+                // Neue Response mit aktualisierten Headers erstellen
+                $updatedResponse = $this->manipulator->withHeaders($response, $updatedHeaders);
+
+
+                return $resultContext->withResponse($updatedResponse);
+            }
+        }
+
+        return $resultContext;
+    }
+}
diff --git a/src/Framework/Http/Middlewares/RequestIdMiddleware.php b/src/Framework/Http/Middlewares/RequestIdMiddleware.php
new file mode 100644
index 00000000..3a35ae63
--- /dev/null
+++ b/src/Framework/Http/Middlewares/RequestIdMiddleware.php
@@ -0,0 +1,48 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Http\Middlewares;
+
+use App\Framework\Http\HttpMiddleware;
+use App\Framework\Http\MiddlewareContext;
+use App\Framework\Http\MiddlewarePriority;
+use App\Framework\Http\MiddlewarePriorityAttribute;
+use App\Framework\Http\RequestStateManager;
+use App\Framework\Http\RequestIdGenerator;
+use App\Framework\Http\ResponseManipulator;
+
+/**
+ * Middleware zur Verarbeitung von Request-IDs.
+ * Generiert eine HMAC-signierte Request-ID und fügt sie als Header hinzu.
+ */
+#[MiddlewarePriorityAttribute(MiddlewarePriority::VERY_EARLY)]
+final readonly class RequestIdMiddleware implements HttpMiddleware
+{
+    public function __construct(
+        private RequestIdGenerator $requestIdGenerator,
+        private ResponseManipulator $manipulator
+    ) {}
+
+    public function __invoke(MiddlewareContext $context, callable $next, RequestStateManager $stateManager): MiddlewareContext
+    {
+        // Request-ID generieren/validieren
+        $requestId = $this->requestIdGenerator->generate();
+
+        // Request-ID an den weiteren Verarbeitungskontext weitergeben
+        $resultContext = $next($context);
+
+        // Request-ID in die Response-Header setzen, falls eine Response vorhanden ist
+        if ($resultContext->hasResponse()) {
+            $response = $resultContext->response;
+            $headers = $response->headers->with(
+                $this->requestIdGenerator::getHeaderName(),
+                $requestId->toString()
+            );
+            $updatedResponse = $this->manipulator->withHeaders($response, $headers);
+
+            return $resultContext->withResponse($updatedResponse);
+        }
+
+        return $resultContext;
+    }
+}
diff --git a/src/Framework/Http/Middlewares/RequestLoggingMiddleware.php b/src/Framework/Http/Middlewares/RequestLoggingMiddleware.php
new file mode 100644
index 00000000..55e65756
--- /dev/null
+++ b/src/Framework/Http/Middlewares/RequestLoggingMiddleware.php
@@ -0,0 +1,59 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Http\Middlewares;
+
+use App\Framework\Http\HttpMiddleware;
+use App\Framework\Http\MiddlewareContext;
+use App\Framework\Http\MiddlewarePriority;
+use App\Framework\Http\MiddlewarePriorityAttribute;
+use App\Framework\Http\RequestStateManager;
+use App\Framework\Http\Request;
+use App\Framework\Http\Response;
+use App\Framework\Logging\Logger;
+
+#[MiddlewarePriorityAttribute(MiddlewarePriority::LOGGING)]
+final readonly class RequestLoggingMiddleware implements HttpMiddleware
+{
+    public function __construct(
+        private Logger $logger
+    ){}
+    public function __invoke(MiddlewareContext $context, callable $next, RequestStateManager $stateManager): MiddlewareContext
+    {
+        $startTime = microtime(true);
+
+        $request = $context->request;
+
+        // Anfrage loggen
+        $path = $request->path;
+        $method = $request->method;
+
+        // Nächste Middleware aufrufen
+        $resultContext = $next($context);
+
+        // Antwort loggen
+        $endTime = microtime(true);
+        $duration = round(($endTime - $startTime) * 1000, 2);
+
+        // Statuscode nur abrufen, wenn eine Response vorhanden ist
+        $status = $resultContext->hasResponse()
+            ? $resultContext->response->status->value
+            : 'keine Response';
+
+        // Log-Eintrag erstellen
+        $logEntry = sprintf(
+            '[%s] %s %s - %d (%s ms)',
+            date('Y-m-d H:i:s'),
+            $method->value,
+            $path,
+            $status,
+            $duration
+        );
+
+        $this->logger->info($logEntry);
+
+        // In Log-Datei schreiben...
+
+        return $resultContext;
+    }
+}
diff --git a/src/Framework/Http/Middlewares/ResponseGeneratorMiddleware.php b/src/Framework/Http/Middlewares/ResponseGeneratorMiddleware.php
new file mode 100644
index 00000000..25ff0739
--- /dev/null
+++ b/src/Framework/Http/Middlewares/ResponseGeneratorMiddleware.php
@@ -0,0 +1,64 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Http\Middlewares;
+
+use App\Framework\Http\HttpMiddleware;
+use App\Framework\Http\MiddlewareContext;
+use App\Framework\Http\MiddlewarePriority;
+use App\Framework\Http\MiddlewarePriorityAttribute;
+use App\Framework\Http\RequestStateManager;
+use App\Framework\Router\RouteResponder;
+
+#[MiddlewarePriorityAttribute(MiddlewarePriority::ROUTING, -1)]
+final readonly class ResponseGeneratorMiddleware implements HttpMiddleware
+{
+    public function __construct(
+        private RouteResponder $responder,
+    ) {}
+
+    public function __invoke(MiddlewareContext $context, callable $next, RequestStateManager $stateManager): MiddlewareContext
+    {
+        $request = $context->request;
+
+        if($stateManager->has('controllerResult')) {
+            $originalResponse = $this->responder->respond($stateManager->get('controllerResult'));
+
+            // Kontext mit der generierten Response aktualisieren
+            $updatedContext = $context->withResponse($originalResponse);
+
+
+
+            $resultContext = $next($updatedContext);
+
+            if(!$resultContext->hasResponse() && $originalResponse !== null) {
+                return $resultContext->withResponse($originalResponse);
+            }
+
+            return $resultContext;
+        }
+
+
+        /*// Prüfen, ob es sich um einen angereicherten Request handelt
+        if ($request instanceof EnrichedRequest && $request->result) {
+            // Response aus dem Controller-Ergebnis generieren
+            $originalResponse = $this->responder->respond($request->result);
+
+            // Kontext mit der generierten Response aktualisieren
+            $updatedContext = $context->withResponse($originalResponse);
+
+
+
+            $resultContext = $next($updatedContext);
+
+            if(!$resultContext->hasResponse() && $originalResponse !== null) {
+                return $resultContext->withResponse($originalResponse);
+            }
+
+            return $resultContext;
+        }*/
+
+        // Immer die nächste Middleware aufrufen, auch wenn bereits eine Response generiert wurde
+        return $next($context);
+    }
+}
diff --git a/src/Framework/Http/Middlewares/RoutingMiddleware.php b/src/Framework/Http/Middlewares/RoutingMiddleware.php
new file mode 100644
index 00000000..d8c00df1
--- /dev/null
+++ b/src/Framework/Http/Middlewares/RoutingMiddleware.php
@@ -0,0 +1,99 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Http\Middlewares;
+
+use App\Framework\Auth\Auth;
+use App\Framework\Http\HttpMiddleware;
+use App\Framework\Http\MiddlewareContext;
+use App\Framework\Http\MiddlewarePriority;
+use App\Framework\Http\MiddlewarePriorityAttribute;
+use App\Framework\Http\RequestStateManager;
+use App\Framework\Meta\MetaData;
+use App\Framework\Router\ActionResult;
+use App\Framework\Router\Exception\RouteNotFound;
+use App\Framework\Router\HttpRouter;
+use App\Framework\Router\Result\ContentNegotiationResult;
+use App\Framework\Router\Result\JsonResult;
+use App\Framework\Router\Result\Redirect;
+use App\Framework\Router\Result\ViewResult;
+use App\Framework\Router\RouteDispatcher;
+
+#[MiddlewarePriorityAttribute(MiddlewarePriority::ROUTING)]
+final readonly class RoutingMiddleware implements HttpMiddleware
+{
+    public function __construct(
+        private HttpRouter $router,
+        private RouteDispatcher $dispatcher,
+    ) {}
+
+    /**
+     * Invokes the middleware logic to process a request and response through the provided context.
+     * It enriches the request based on the matched route and dispatches the corresponding controller logic.
+     * Then, it updates the context with the enriched request and passes it to the next middleware.
+     *
+     * @param MiddlewareContext $context The context containing the request and response.
+     * @param callable $next The next middleware to invoke in the chain.
+     * @param RequestStateManager $stateManager
+     * @return MiddlewareContext The updated middleware context after processing.
+     * @throws RouteNotFound If the route cannot be matched in the current context.
+     */
+    public function __invoke(MiddlewareContext $context, callable $next, RequestStateManager $stateManager): MiddlewareContext
+    {
+        $request = $context->request;
+        $routeContext = $this->router->match($request);
+
+        if (!$routeContext->isSuccess()) {
+            throw new RouteNotFound($routeContext->path);
+        }
+
+        if (in_array(Auth::class, $routeContext->match->route->attributes)) {
+
+            #debug($request->server->getClientIp());
+            $wireguardIp = '172.20.0.1';
+
+            $ip = $request->server->getClientIp();
+            if ($ip->value !== $wireguardIp) {
+                throw new RouteNotFound($routeContext->path);
+            }
+        }
+
+
+        // Controller-Logik ausführen
+        $result = $this->dispatcher->dispatch($routeContext);
+
+        if ($result instanceof ContentNegotiationResult) {
+            $result = $this->contentNegotiation($result);
+        }
+
+        $stateManager->set('controllerResult', $result);
+
+        // Erstellen eines angereicherten Requests mit dem Controller-Ergebnis
+        #$enrichedRequest = new EnrichedRequest($request, $result);
+
+        // Kontext mit dem angereicherten Request aktualisieren
+        #$updatedContext = new MiddlewareContext($enrichedRequest, $context->response);
+
+        $updatedContext = $context;
+
+        // Nächste Middleware aufrufen
+        return $next($updatedContext);
+    }
+
+    private function contentNegotiation(ContentNegotiationResult $response): ActionResult
+    {
+        $isJson = true;
+
+        if ($isJson) {
+            return new JsonResult($response->jsonPayload);
+        }
+        if ($response->redirectTo !== null) {
+            return new Redirect($response->redirectTo);
+        }
+        if ($response->viewTemplate !== null) {
+            return new ViewResult(template: $response->viewTemplate,metaData: new MetaData(''), data: $response->viewData);
+        }
+        // Optional: Fallback, z.B. Fehler- oder Defaultseite
+        return new JsonResult(['message' => 'Not found']);
+    }
+}
diff --git a/src/Framework/Http/Middlewares/SecurityHeaderConfig.php b/src/Framework/Http/Middlewares/SecurityHeaderConfig.php
new file mode 100644
index 00000000..caf0ffc0
--- /dev/null
+++ b/src/Framework/Http/Middlewares/SecurityHeaderConfig.php
@@ -0,0 +1,48 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Http\Middlewares;
+
+final readonly class SecurityHeaderConfig
+{
+    public function __construct(
+        public string $hstsHeader = 'max-age=63072000; includeSubDomains; preload',
+        public string $frameOptions = 'DENY',
+        public string $referrerPolicy = 'strict-origin-when-cross-origin',
+        public string $contentSecurityPolicy = "default-src 'self'; script-src 'self' 'unsafe-inline'; style-src 'self' 'unsafe-inline'; img-src 'self' data: https:; font-src 'self'; connect-src 'self'; media-src 'self'; object-src 'none'; child-src 'self'; frame-ancestors 'none'; form-action 'self'; base-uri 'self'",
+        public string $permissionsPolicy = 'geolocation=(), microphone=(), camera=()',
+        public string $crossOriginEmbedderPolicy = 'require-corp',
+        public string $crossOriginOpenerPolicy = 'same-origin',
+        public string $crossOriginResourcePolicy = 'same-origin',
+        public bool $enableInDevelopment = false
+    ) {}
+
+    /**
+     * Erstellt eine Konfiguration für Entwicklungsumgebung mit weniger restriktiven Einstellungen
+     */
+    public static function forDevelopment(): self
+    {
+        return new self(
+            hstsHeader: 'max-age=3600', // Kürzere HSTS-Zeit für Development
+            frameOptions: 'SAMEORIGIN',  // Weniger restriktiv für Development-Tools
+            contentSecurityPolicy: "default-src 'self'; script-src 'self' 'unsafe-inline' 'unsafe-eval'; style-src 'self' 'unsafe-inline'; img-src 'self' data: https: blob:; font-src 'self' https:; connect-src 'self' ws: wss:; media-src 'self'; object-src 'none'; child-src 'self'; frame-ancestors 'self'; form-action 'self'; base-uri 'self'",
+            crossOriginEmbedderPolicy: 'unsafe-none',
+            crossOriginOpenerPolicy: 'unsafe-none',
+            crossOriginResourcePolicy: 'cross-origin',
+            enableInDevelopment: true
+        );
+    }
+
+    /**
+     * Erstellt eine Konfiguration für Produktionsumgebung mit maximaler Sicherheit
+     */
+    public static function forProduction(): self
+    {
+        return new self(
+            hstsHeader: 'max-age=63072000; includeSubDomains; preload',
+            frameOptions: 'DENY',
+            contentSecurityPolicy: "default-src 'none'; script-src 'self'; style-src 'self'; img-src 'self' data:; font-src 'self'; connect-src 'self'; media-src 'self'; object-src 'none'; child-src 'none'; frame-ancestors 'none'; form-action 'self'; base-uri 'self'; upgrade-insecure-requests",
+            permissionsPolicy: 'geolocation=(), microphone=(), camera=(), payment=(), usb=(), magnetometer=(), gyroscope=(), speaker=()',
+        );
+    }
+}
diff --git a/src/Framework/Http/Middlewares/SecurityHeaderMiddleware.php b/src/Framework/Http/Middlewares/SecurityHeaderMiddleware.php
new file mode 100644
index 00000000..33e02644
--- /dev/null
+++ b/src/Framework/Http/Middlewares/SecurityHeaderMiddleware.php
@@ -0,0 +1,78 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Http\Middlewares;
+
+use App\Framework\Http\HttpMiddleware;
+use App\Framework\Http\MiddlewareContext;
+use App\Framework\Http\MiddlewarePriority;
+use App\Framework\Http\MiddlewarePriorityAttribute;
+use App\Framework\Http\RequestStateManager;
+use App\Framework\Http\ResponseManipulator;
+
+#[MiddlewarePriorityAttribute(MiddlewarePriority::SECURITY)]
+final readonly class SecurityHeaderMiddleware implements HttpMiddleware
+{
+    public function __construct(
+        private ResponseManipulator $manipulator,
+        private SecurityHeaderConfig $config = new SecurityHeaderConfig()
+    ) {}
+
+    public function __invoke(MiddlewareContext $context, callable $next, RequestStateManager $stateManager): MiddlewareContext
+    {
+        $this->removePoweredByHeader();
+
+        // Nächste Middleware aufrufen
+        $resultContext = $next($context);
+
+        // Wenn eine Response vorhanden ist, Security-Header hinzufügen
+        if ($resultContext->hasResponse()) {
+            $response = $resultContext->response;
+            $updatedHeaders = $response->headers;
+
+            // Alle Security-Header hinzufügen
+            foreach ($this->getSecurityHeaders() as $name => $value) {
+                if ($this->shouldAddHeader($name, $updatedHeaders)) {
+                    $updatedHeaders = $updatedHeaders->with($name, $value);
+                }
+            }
+
+            // Neue Response mit aktualisierten Headers erstellen
+            $updatedResponse = $this->manipulator->withHeaders($response, $updatedHeaders);
+
+            return $resultContext->withResponse($updatedResponse);
+        }
+
+        return $resultContext;
+    }
+
+    private function getSecurityHeaders(): array
+    {
+        return [
+            'Strict-Transport-Security' => $this->config->hstsHeader,
+            'X-Frame-Options' => $this->config->frameOptions,
+            'X-Content-Type-Options' => 'nosniff',
+            'Referrer-Policy' => $this->config->referrerPolicy,
+            'Content-Security-Policy' => $this->config->contentSecurityPolicy,
+            'Permissions-Policy' => $this->config->permissionsPolicy,
+            'X-Permitted-Cross-Domain-Policies' => 'none',
+            'Cross-Origin-Embedder-Policy' => $this->config->crossOriginEmbedderPolicy,
+            'Cross-Origin-Opener-Policy' => $this->config->crossOriginOpenerPolicy,
+            'Cross-Origin-Resource-Policy' => $this->config->crossOriginResourcePolicy,
+        ];
+    }
+
+    private function shouldAddHeader(string $headerName, $currentHeaders): bool
+    {
+        // Header nur hinzufügen, wenn er noch nicht gesetzt ist
+        return !$currentHeaders->has($headerName);
+    }
+
+    private function removePoweredByHeader():void
+    {
+        if (!headers_sent()) {
+            header_remove('X-Powered-By');
+            header_remove('Server');
+        }
+    }
+}
diff --git a/src/Framework/Http/MimeType.php b/src/Framework/Http/MimeType.php
new file mode 100644
index 00000000..2124f093
--- /dev/null
+++ b/src/Framework/Http/MimeType.php
@@ -0,0 +1,41 @@
+<?php
+
+namespace App\Framework\Http;
+
+enum MimeType: string
+{
+    // Text
+    case TEXT_PLAIN = 'text/plain';
+    case TEXT_HTML = 'text/html';
+    case TEXT_CSS = 'text/css';
+    case TEXT_CSV = 'text/csv';
+    case TEXT_JAVASCRIPT = 'text/javascript';
+
+    // Application
+    case APPLICATION_JSON = 'application/json';
+    case APPLICATION_XML = 'application/xml';
+    case APPLICATION_FORM = 'application/x-www-form-urlencoded';
+    case APPLICATION_OCTET_STREAM = 'application/octet-stream';
+    case APPLICATION_PDF = 'application/pdf';
+    case APPLICATION_ZIP = 'application/zip';
+
+    // Images
+    case IMAGE_JPEG = 'image/jpeg';
+    case IMAGE_PNG = 'image/png';
+    case IMAGE_GIF = 'image/gif';
+    case IMAGE_SVG = 'image/svg+xml';
+    case IMAGE_WEBP = 'image/webp';
+
+    // Audio
+    case AUDIO_MPEG = 'audio/mpeg';
+    case AUDIO_WAV = 'audio/wav';
+    case AUDIO_OGG = 'audio/ogg';
+
+    // Video
+    case VIDEO_MP4 = 'video/mp4';
+    case VIDEO_WEBM = 'video/webm';
+
+    // Multipart
+    case MULTIPART_FORM_DATA = 'multipart/form-data';
+
+}
diff --git a/src/Framework/Http/NamespacedState.php b/src/Framework/Http/NamespacedState.php
new file mode 100644
index 00000000..d71be0c3
--- /dev/null
+++ b/src/Framework/Http/NamespacedState.php
@@ -0,0 +1,37 @@
+<?php
+
+namespace App\Framework\Http;
+
+/**
+ *
+ * class AuthMiddleware
+ * {
+ *      public function __invoke($context, $next, $state)
+ *      {
+ *          $auth = $state->namespace('auth');
+ *
+ *          $auth->set('user', $user);              Intern: 'auth.user'
+ *          $auth->set('permissions', $perms);      Intern: 'auth.permissions'
+ *
+ *      return $next($context);
+ *      }
+ * }
+ */
+
+final readonly class NamespacedState
+{
+    public function __construct(
+        private RequestStateManager $stateManager,
+        private string              $namespace
+    ){}
+
+    public function set(string $key, mixed $value): void
+    {
+        $this->stateManager->set("{$this->namespace}.{$key}", $value);
+    }
+
+    public function get(string $key, mixed $default = null): mixed
+    {
+        return $this->stateManager->get("{$this->namespace}.{$key}", $default);
+    }
+}
diff --git a/src/Framework/Http/Range.php b/src/Framework/Http/Range.php
new file mode 100644
index 00000000..83fe758d
--- /dev/null
+++ b/src/Framework/Http/Range.php
@@ -0,0 +1,16 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Http;
+
+final readonly class Range
+{
+    public int $length;
+    public function __construct(
+        public int $start,
+        public int $end,
+        public int $total
+    ) {
+        $this->length = $end - $start + 1;
+    }
+}
diff --git a/src/Framework/Http/RateLimiter/RateLimiterConfig.php b/src/Framework/Http/RateLimiter/RateLimiterConfig.php
new file mode 100644
index 00000000..84e7b771
--- /dev/null
+++ b/src/Framework/Http/RateLimiter/RateLimiterConfig.php
@@ -0,0 +1,100 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Http\RateLimiter;
+
+/**
+ * Konfiguration für verschiedene Rate Limiting Strategien.
+ * Diese Klasse ermöglicht die Definition unterschiedlicher Rate-Limits
+ * für verschiedene Teile der Anwendung.
+ */
+final class RateLimiterConfig
+{
+    /**
+     * @var array<string, array{limit: int, window: int}> Pfad-Muster (Regex) => Limit-Konfiguration
+     */
+    private array $pathLimits = [];
+
+    /**
+     * @param int $defaultLimit Standardmäßige Anzahl an erlaubten Anfragen im Zeitfenster
+     * @param int $windowSeconds Länge des Zeitfensters in Sekunden
+     */
+    public function __construct(
+        private readonly int $defaultLimit = 60,
+        private readonly int $windowSeconds = 60
+    ) {
+    }
+
+    /**
+     * Fügt ein spezifisches Limit für einen Pfad hinzu.
+     *
+     * @param string $pathPattern Ein regulärer Ausdruck, der den Pfad beschreibt
+     * @param int $limit Anzahl der erlaubten Anfragen
+     * @param int|null $window Zeitfenster in Sekunden (optional, nutzt Standard wenn nicht angegeben)
+     * @return self
+     */
+    public function addPathLimit(string $pathPattern, int $limit, ?int $window = null): self
+    {
+        $this->pathLimits[$pathPattern] = [
+            'limit' => $limit,
+            'window' => $window ?? $this->windowSeconds
+        ];
+
+        return $this;
+    }
+
+    /**
+     * Fügt ein strengeres Limit für API-Endpunkte hinzu.
+     *
+     * @param int $limit Anzahl der erlaubten Anfragen
+     * @param int|null $window Zeitfenster in Sekunden
+     * @return self
+     */
+    public function withApiLimit(int $limit, ?int $window = null): self
+    {
+        return $this->addPathLimit('#^/api/#', $limit, $window);
+    }
+
+    /**
+     * Fügt ein strengeres Limit für Authentifizierungs-Endpunkte hinzu.
+     *
+     * @param int $limit Anzahl der erlaubten Anfragen
+     * @param int|null $window Zeitfenster in Sekunden
+     * @return self
+     */
+    public function withAuthLimit(int $limit, ?int $window = null): self
+    {
+        return $this->addPathLimit('#^/(login|register|password-reset)#', $limit, $window);
+    }
+
+    /**
+     * Gibt das Standard-Limit zurück.
+     *
+     * @return int
+     */
+    public function getDefaultLimit(): int
+    {
+        return $this->defaultLimit;
+    }
+
+    /**
+     * Gibt das Standard-Zeitfenster zurück.
+     *
+     * @return int
+     */
+    public function getWindowSeconds(): int
+    {
+        return $this->windowSeconds;
+    }
+
+    /**
+     * Gibt alle pfadspezifischen Limits zurück.
+     *
+     * @return array<string, array{limit: int, window: int}>
+     */
+    public function getPathLimits(): array
+    {
+        return $this->pathLimits;
+    }
+}
diff --git a/src/Framework/Http/RateLimiter/RedisRateLimiter.php b/src/Framework/Http/RateLimiter/RedisRateLimiter.php
new file mode 100644
index 00000000..75487174
--- /dev/null
+++ b/src/Framework/Http/RateLimiter/RedisRateLimiter.php
@@ -0,0 +1,90 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Http\RateLimiter;
+
+use Predis\Client as RedisClient;
+
+/**
+ * Redis-basierte Implementierung eines Rate-Limiters.
+ * Verwendet Redis Sorted Sets für präzises Sliding Window Rate Limiting.
+ */
+final readonly class RedisRateLimiter
+{
+    private const string KEY_PREFIX = 'rate_limit:';
+
+    public function __construct(
+        private RedisClient $redis
+    ) {
+    }
+
+    /**
+     * Prüft, ob eine Anfrage das Rate-Limit überschreitet.
+     *
+     * @param string $identifier Eindeutiger Identifikator (z.B. IP-Adresse)
+     * @param string $action Optional: Name der Aktion (z.B. 'login', 'api')
+     * @param int $limit Anzahl der erlaubten Anfragen im Zeitfenster
+     * @param int $windowSeconds Länge des Zeitfensters in Sekunden
+     * @return array{allowed: bool, current: int, remaining: int, reset: int} Ergebnis der Prüfung
+     */
+    public function check(
+        string $identifier,
+        string $action = 'default',
+        int $limit = 60,
+        int $windowSeconds = 60
+    ): array {
+        $key = $this->getKey($identifier, $action);
+        $now = time();
+
+        // Anfragen entfernen, die außerhalb des Zeitfensters liegen
+        $this->redis->zremrangebyscore($key, 0, $now - $windowSeconds);
+
+        // Aktuelle Anzahl der Anfragen im Zeitfenster
+        $current = (int)$this->redis->zcard($key);
+
+        // Wenn noch unter dem Limit, diese Anfrage hinzufügen
+        if ($current < $limit) {
+            $this->redis->zadd($key, [$now => $now]);
+            $this->redis->expire($key, $windowSeconds);
+            $current++;
+        }
+
+        // Zeitpunkt berechnen, wann das Limit zurückgesetzt wird
+        $oldestRequest = $this->redis->zrange($key, 0, 0, ['WITHSCORES' => true]);
+        $resetTime = 0;
+
+        if (!empty($oldestRequest)) {
+            $oldestTimestamp = (int)reset($oldestRequest);
+            $resetTime = $oldestTimestamp + $windowSeconds;
+        }
+
+        return [
+            'allowed' => $current <= $limit,
+            'current' => $current,
+            'remaining' => max(0, $limit - $current),
+            'reset' => $resetTime - $now
+        ];
+    }
+
+    /**
+     * Erzeugt einen Reset des Rate-Limits für einen bestimmten Identifikator.
+     * Nützlich z.B. nach erfolgreicher Authentifizierung.
+     *
+     * @param string $identifier Eindeutiger Identifikator
+     * @param string $action Optional: Name der Aktion
+     */
+    public function reset(string $identifier, string $action = 'default'): void
+    {
+        $key = $this->getKey($identifier, $action);
+        $this->redis->del($key);
+    }
+
+    /**
+     * Erzeugt den Redis-Schlüssel für den gegebenen Identifikator und die Aktion.
+     */
+    private function getKey(string $identifier, string $action): string
+    {
+        return self::KEY_PREFIX . "{$identifier}:{$action}";
+    }
+}
diff --git a/src/Framework/Http/Request.php b/src/Framework/Http/Request.php
index a4a6086c..ec90684f 100644
--- a/src/Framework/Http/Request.php
+++ b/src/Framework/Http/Request.php
@@ -4,19 +4,23 @@ declare(strict_types=1);
 
 namespace App\Framework\Http;
 
+use App\Framework\Http\Cookies\Cookies;
+
 interface Request
 {
-    public Headers $headers{
-        get;
-    }
+    public Headers $headers { get; }
 
-    public string $body{
-        get;
-    }
+    public RequestId $id {get; }
 
-    public HttpMethod $method{
-        get;
-    }
+    public string $body { get; }
 
+    public Method $method { get; }
 
+    public array $queryParams { get; }
+
+    public string $path { get; }
+
+    public Cookies $cookies { get; }
+
+    public ServerEnvironment $server {get;}
 }
diff --git a/src/Framework/Http/RequestBody.php b/src/Framework/Http/RequestBody.php
new file mode 100644
index 00000000..ea63059d
--- /dev/null
+++ b/src/Framework/Http/RequestBody.php
@@ -0,0 +1,46 @@
+<?php
+
+namespace App\Framework\Http;
+
+final readonly class RequestBody
+{
+
+    public array $data;
+
+    public function __construct(Method $method, Headers $headers, string $body, array $post)
+    {
+
+        if ($method === Method::GET) {
+            $this->data =  $_GET;
+            return;
+        }
+
+        $contentType = $headers->get(HeaderKey::CONTENT_TYPE);
+
+        // Prüfen, ob $contentType ein Array ist und konvertiere es ggf. in einen String
+        if (is_array($contentType)) {
+            $contentType = $contentType[0] ?? '';
+        } elseif ($contentType === null) {
+            $contentType = '';
+        }
+
+        if (str_contains($contentType, MimeType::APPLICATION_JSON->value)) {
+            $parsedBody = json_decode($body, true) ?? [];
+        } elseif (str_contains($contentType, MimeType::APPLICATION_FORM->value)) {
+            parse_str($body, $parsedBody);
+        } elseif (str_contains($contentType, MimeType::MULTIPART_FORM_DATA->value)) {
+            // Bei multipart/form-data verwende $_POST
+            $parsedBody = $post;
+        } else {
+            // Fallback
+            $parsedBody = [];
+        }
+
+        $this->data = $parsedBody;
+    }
+
+    public function get(string $key, mixed $default = null): mixed
+    {
+        return $this->data[$key] ?? $default;
+    }
+}
diff --git a/src/Framework/Http/RequestFactory.php b/src/Framework/Http/RequestFactory.php
new file mode 100644
index 00000000..c7efc97d
--- /dev/null
+++ b/src/Framework/Http/RequestFactory.php
@@ -0,0 +1,102 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Http;
+
+use App\Framework\DI\Initializer;
+use App\Framework\Http\Cookies\Cookie;
+use App\Framework\Http\Cookies\Cookies;
+use App\Framework\Router\Exception\RouteNotFound;
+
+/**
+ * Erstellt HTTP-Requests aus den globalen Variablen
+ */
+final readonly class RequestFactory
+{
+    public function __construct(
+        private RequestIdGenerator $requestIdGenerator
+    ) {}
+
+    /**
+     * Erstellt einen HTTP-Request aus den globalen Variablen
+     */
+    #[Initializer]
+    public function createFromGlobals(): Request
+    {
+        $server = new ServerEnvironment($_SERVER);
+
+        $originalRequestUri = (string)$server->getRequestUri();
+        $rawPath = parse_url($originalRequestUri, PHP_URL_PATH);
+
+        if ($rawPath === false) {
+            throw new RouteNotFound($originalRequestUri);
+        }
+
+        if($rawPath !== '/') {
+            $rawPath = rtrim($rawPath, '/');
+        }
+
+        $headers = $this->getHeadersFromServer();
+        $cookies = $this->getCookiesFromServer();
+        $method = $server->getRequestMethod();
+        $body = file_get_contents('php://input') ?: '';
+
+        $parsedBody = new RequestBody($method, $headers, $body, $_POST);
+
+        if ($method === Method::POST) {
+            $_method = Method::tryFrom($parsedBody->get('_method', ''));
+            if($_method !== null) {
+                $method = $_method;
+            }
+        }
+
+
+        return new HttpRequest(
+            method: $method,
+            headers: $headers,
+            body: $body,
+            path: $rawPath,
+            queryParams: $_GET,
+            files: new UploadedFiles($_FILES),
+            cookies: $cookies,
+            server: $server,
+            id: $this->requestIdGenerator->generate(),
+            parsedBody: $parsedBody
+        );
+    }
+
+    /**
+     * Extrahiert HTTP-Header aus den Server-Variablen
+     */
+    private function getHeadersFromServer(): Headers
+    {
+        $headers = new Headers();
+
+        foreach ($_SERVER as $key => $value) {
+            // Prüfen auf HTTP_-Präfix (Standard-Header)
+            if (str_starts_with($key, 'HTTP_')) {
+                $headerName = str_replace('_', '-', substr($key, 5));
+                $headers = $headers->with($headerName, $value);
+            }
+            // Spezielle Header wie Content-Type und Content-Length haben kein HTTP_-Präfix
+            elseif (in_array($key, ['CONTENT_TYPE', 'CONTENT_LENGTH'])) {
+                $headerName = str_replace('_', '-', $key);
+                $headers = $headers->with($headerName, $value);
+            }
+        }
+
+        return $headers;
+    }
+
+    private function getCookiesFromServer(): Cookies
+    {
+        $cookies = [];
+
+        foreach ($_COOKIE as $key => $value) {
+            $cookies[] = new Cookie($key, $value);
+        }
+
+        return new Cookies(...$cookies);
+    }
+}
diff --git a/src/Framework/Http/RequestId.php b/src/Framework/Http/RequestId.php
new file mode 100644
index 00000000..56658cc6
--- /dev/null
+++ b/src/Framework/Http/RequestId.php
@@ -0,0 +1,112 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Http;
+
+/**
+ * Repräsentiert eine kryptografisch sichere und signierte Request-ID.
+ * Enthält sowohl die ID selbst als auch deren HMAC-Signatur zur Validierung.
+ */
+final readonly class RequestId
+{
+    private string $id;
+    private string $signature;
+    private string $combined;
+
+    /**
+     * Erstellt eine neue Request-ID oder parsed eine bestehende
+     *
+     * @param string|null $combined Wenn nicht null, wird diese ID validiert und verwendet
+     * @param string $secret Das Secret für die HMAC-Signatur
+     */
+    public function __construct(?string $combined = null, string $secret = '')
+    {
+        // Secret über eine Umgebungsvariable beziehen, falls nicht angegeben
+        $secret = $secret ?: ($_ENV['APP_SECRET'] ?? 'default-secret-change-me');
+
+        if ($combined !== null && self::isValidFormat($combined)) {
+            // Bestehende ID parsen
+            [$rawId, $signature] = explode('.', $combined, 2);
+
+            // Signatur validieren
+            $expectedSignature = $this->generateSignature($rawId, $secret);
+
+            if (!hash_equals($expectedSignature, $signature)) {
+                // Bei ungültiger Signatur, neue ID erstellen
+                $this->generateNew($secret);
+            } else {
+                // Bei gültiger Signatur, diese ID verwenden
+                $this->id = $rawId;
+                $this->signature = $signature;
+                $this->combined = $combined;
+            }
+        } else {
+            // Neue ID erstellen
+            $this->generateNew($secret);
+        }
+    }
+
+    /**
+     * Generiert eine neue Request-ID mit Signatur
+     */
+    private function generateNew(string $secret): void
+    {
+        // Zufällige ID generieren (16 Byte = 32 Hex-Zeichen)
+        $this->id = bin2hex(random_bytes(16));
+
+        // Signatur erstellen
+        $this->signature = $this->generateSignature($this->id, $secret);
+
+        // Kombinierte Darstellung erstellen
+        $this->combined = $this->id . '.' . $this->signature;
+    }
+
+    /**
+     * Generiert eine HMAC-Signatur für die ID
+     */
+    private function generateSignature(string $id, string $secret): string
+    {
+        return hash_hmac('sha256', $id, $secret, false);
+    }
+
+    /**
+     * Prüft, ob eine kombinierte ID das korrekte Format hat
+     */
+    private static function isValidFormat(string $combined): bool
+    {
+        // Format: 32 Hex-Zeichen + Punkt + 64 Hex-Zeichen (SHA-256 HMAC)
+        return preg_match('/^[a-f0-9]{32}\.[a-f0-9]{64}$/i', $combined) === 1;
+    }
+
+    /**
+     * Gibt die kombinierte ID (ID + Signatur) zurück
+     */
+    public function toString(): string
+    {
+        return $this->combined;
+    }
+
+    /**
+     * Gibt nur die eigentliche ID ohne Signatur zurück
+     */
+    public function getId(): string
+    {
+        return $this->id;
+    }
+
+    /**
+     * Gibt die Signatur zurück
+     */
+    public function getSignature(): string
+    {
+        return $this->signature;
+    }
+
+    /**
+     * String-Repräsentation für Debugging
+     */
+    public function __toString(): string
+    {
+        return $this->toString();
+    }
+}
diff --git a/src/Framework/Http/RequestIdGenerator.php b/src/Framework/Http/RequestIdGenerator.php
new file mode 100644
index 00000000..8a0f2473
--- /dev/null
+++ b/src/Framework/Http/RequestIdGenerator.php
@@ -0,0 +1,60 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Http;
+
+use App\Framework\Attributes\Singleton;
+
+/**
+ * Service zur Verwaltung der Request-ID für den aktuellen Request.
+ * Nutzt HMAC-Signierung, um die Integrität der IDs zu gewährleisten.
+ */
+#[Singleton]
+final class RequestIdGenerator
+{
+    private const string REQUEST_ID_HEADER = 'X-Request-ID';
+
+    private ?RequestId $requestId = null;
+    private string $secret;
+
+    /**
+     * Initialisiert den RequestIdGenerator mit einem optionalen Secret
+     */
+    public function __construct(string $secret = '')
+    {
+        // Secret über eine Umgebungsvariable beziehen, falls nicht angegeben
+        $this->secret = $secret ?: ($_ENV['APP_SECRET'] ?? 'default-secret-change-me');
+    }
+
+    /**
+     * Generiert eine neue Request-ID oder validiert und verwendet eine bestehende
+     */
+    public function generate(): RequestId
+    {
+        if ($this->requestId === null) {
+            // Prüfen, ob eine Request-ID im Header vorhanden ist
+            $headerRequestId = $_SERVER[str_replace('-', '_', 'HTTP_' . self::REQUEST_ID_HEADER)] ?? null;
+
+            // Neue RequestId erstellen (validiert automatisch die Header-ID, falls vorhanden)
+            $this->requestId = new RequestId($headerRequestId, $this->secret);
+        }
+
+        return $this->requestId;
+    }
+
+    /**
+     * Gibt die aktuelle Request-ID zurück oder null, wenn noch keine generiert wurde
+     */
+    public function getCurrentId(): ?RequestId
+    {
+        return $this->requestId;
+    }
+
+    /**
+     * Gibt den Header-Namen für die Request-ID zurück
+     */
+    public static function getHeaderName(): string
+    {
+        return self::REQUEST_ID_HEADER;
+    }
+}
diff --git a/src/Framework/Http/RequestStateManager.php b/src/Framework/Http/RequestStateManager.php
new file mode 100644
index 00000000..75555e34
--- /dev/null
+++ b/src/Framework/Http/RequestStateManager.php
@@ -0,0 +1,41 @@
+<?php
+
+namespace App\Framework\Http;
+
+use WeakMap;
+
+final class RequestStateManager
+{
+    public function __construct(
+        private WeakMap          $requestStates,
+        private readonly Request $request,
+    ) {}
+
+    public function namespace(string $namespace): NamespacedState
+    {
+        return new NamespacedState($this, $namespace);
+    }
+
+    public function set(string $key, mixed $value): void
+    {
+        if(!isset($this->requestStates[$this->request])) {
+            $this->requestStates[$this->request] = [];
+        }
+        $this->requestStates[$this->request][$key] = $value;
+    }
+
+    public function get(string $key, mixed $default = null): mixed
+    {
+        return $this->requestStates[$this->request][$key] ?? $default;
+    }
+
+    public function has(string $key): bool
+    {
+        return isset($this->requestStates[$this->request][$key]);
+    }
+
+    public function remove(string $key): void
+    {
+        unset($this->requestStates[$this->request][$key]);
+    }
+}
diff --git a/src/Framework/Http/Response.php b/src/Framework/Http/Response.php
index 67c0dd49..9a8dd457 100644
--- a/src/Framework/Http/Response.php
+++ b/src/Framework/Http/Response.php
@@ -6,15 +6,9 @@ namespace App\Framework\Http;
 
 interface Response
 {
-    public string $body{
-        get;
-    }
+    public string $body{ get; }
 
-    public Status $status{
-        get;
-    }
+    public Status $status{ get; }
 
-    public Headers $headers{
-        get;
-    }
+    public Headers $headers{ get; }
 }
diff --git a/src/Framework/Http/ResponseEmitter.php b/src/Framework/Http/ResponseEmitter.php
index 4acdd6fa..f9b02034 100644
--- a/src/Framework/Http/ResponseEmitter.php
+++ b/src/Framework/Http/ResponseEmitter.php
@@ -4,38 +4,76 @@ declare(strict_types=1);
 
 namespace App\Framework\Http;
 
-final class ResponseEmitter
+use App\Framework\Http\Emitter\HttpEmitter;
+use App\Framework\Http\Emitter\SseEmitter;
+use App\Framework\Http\Emitter\StreamEmitter;
+use App\Framework\Http\Emitter\WebSocketEmitter;
+use App\Framework\Http\Emitter\AdaptiveStreamEmitter;
+
+final readonly class ResponseEmitter
 {
-    public function emit(Response $response): void
+    public function __construct() {}
+
+    public function emit(Response $response, int $chunkSize = 8192): void
     {
-        // Status-Code senden
-        http_response_code($response->status->value);
+        $responseType = new ResponseTypeDetector()->detect($response);
 
-        // Header senden
-        /*foreach ($response->headers->all() as $name => $values) {
-            #foreach ((array)$values as $value) {
-                header("$name: $values", false);
-            #}
-        }*/
+        #dd($responseType);
 
-        // Header senden
-        foreach ($response->headers->all() as $name => $value) {
-            // Sicherheitsprüfung
-            if (!preg_match('/^[A-Za-z0-9\-]+$/', $name)) {
-                throw new \InvalidArgumentException("Invalid header name: '$name'");
-            }
+        match ($responseType) {
+            ResponseType::SSE => $this->emitSseResponse($response),
+            ResponseType::WEBSOCKET => $this->emitWebSocketResponse($response),
+            ResponseType::MEDIA_STREAM => $this->emitStreamResponse($response),
+            ResponseType::HLS, ResponseType::DASH => $this->emitAdaptiveStreamResponse($response),
+            default => $this->emitHttpResponse($response),
+        };
 
-            // Bei Mehrfach-Headern: ggf. als Array zulassen
-            if (is_array($value)) {
-                foreach ($value as $single) {
-                    header("$name: $single", false); // false = nicht ersetzen
+        /*if (is_string($body)) {
+            // Wenn der Body ein String ist, direkt ausgeben.
+            echo $body;
+        } elseif (is_resource($body) && get_resource_type($body) === 'stream') {
+            // Wenn der Body eine Ressource (Stream) ist, in Chunks lesen und senden.
+            // Dies ist speichereffizient für grosse Dateien.
+            while (!feof($body)) {
+                echo fread($body, $chunkSize);
+                // Ggf. Output-Buffer leeren, um den Chunk sofort an den Client zu senden.
+                if (ob_get_level() > 0) {
+                    ob_flush();
                 }
-            } else {
-                header("$name: $value", true);
+                flush();
             }
-        }
+            fclose($body);
+        }*/
+    }
 
-        // Body ausgeben
-        echo $response->body;
+    /**
+     * Sendet eine SSE-Response mit Streaming-Unterstützung
+     */
+    private function emitSseResponse(Response $response): void
+    {
+        new SseEmitter()->emit($response);
+    }
+
+    /**
+     * Sendet eine WebSocket-Response und startet die WebSocket-Verbindung
+     */
+    private function emitWebSocketResponse(Response $response): void
+    {
+        new WebsocketEmitter()->emit($response);
+    }
+
+    private function emitHttpResponse(Response $response): void
+    {
+        new HttpEmitter()->emit($response);
+    }
+
+    private function emitStreamResponse(Response $response): void
+    {
+        new StreamEmitter()->emit($response);
+    }
+
+    private function emitAdaptiveStreamResponse(Response $response): void
+    {
+        new AdaptiveStreamEmitter()->emit($response);
     }
 }
diff --git a/src/Framework/Http/ResponseManipulator.php b/src/Framework/Http/ResponseManipulator.php
index 4a43d635..9355f493 100644
--- a/src/Framework/Http/ResponseManipulator.php
+++ b/src/Framework/Http/ResponseManipulator.php
@@ -2,10 +2,18 @@
 
 namespace App\Framework\Http;
 
+use App\Framework\Http\Responses\SseResponse;
+use App\Framework\Http\Responses\Streamable;
+
 final readonly class ResponseManipulator
 {
     public function withBody(Response $response, string $body): Response
     {
+        // Spezielle Response-Typen erhalten
+        if ($response instanceof Streamable) {
+            return $response; // SSE-Body wird gestreamt, nicht statisch gesetzt
+        }
+
         return new HttpResponse(
             status: $response->status,
             headers: $response->headers,
@@ -15,8 +23,27 @@ final readonly class ResponseManipulator
 
     public function withHeader(Response $response, string $name, string $value): Response
     {
+        // Spezielle Response-Typen erhalten
+        if ($response instanceof Streamable) {
+            return $response; // SSE-Header sind spezifisch und sollten nicht geändert werden
+        }
+
         $headers = clone $response->headers;
-        $headers->with($name, $value);
+        $headers = $headers->with($name, $value);
+        return new HttpResponse(
+            status: $response->status,
+            headers: $headers,
+            body: $response->body
+        );
+    }
+
+    public function withHeaders(Response $response, Headers $headers): Response
+    {
+        // Spezielle Response-Typen erhalten
+        if ($response instanceof Streamable) {
+            return $response;
+        }
+
         return new HttpResponse(
             status: $response->status,
             headers: $headers,
@@ -26,6 +53,11 @@ final readonly class ResponseManipulator
 
     public function withStatus(Response $response, Status $status): Response
     {
+        // Spezielle Response-Typen erhalten
+        if ($response instanceof Streamable) {
+            return $response;
+        }
+
         return new HttpResponse(
             status: $status,
             headers: $response->headers,
diff --git a/src/Framework/Http/ResponseType.php b/src/Framework/Http/ResponseType.php
new file mode 100644
index 00000000..f4ff76cb
--- /dev/null
+++ b/src/Framework/Http/ResponseType.php
@@ -0,0 +1,14 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Http;
+
+enum ResponseType: string
+{
+    case HTTP = 'http';
+    case SSE = 'sse';
+    case WEBSOCKET = 'websocket';
+    case MEDIA_STREAM = 'media-stream';
+    case HLS = 'hls';
+    case DASH = 'dash';
+}
diff --git a/src/Framework/Http/ResponseTypeDetector.php b/src/Framework/Http/ResponseTypeDetector.php
new file mode 100644
index 00000000..785a37b5
--- /dev/null
+++ b/src/Framework/Http/ResponseTypeDetector.php
@@ -0,0 +1,86 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Http;
+
+use App\Framework\Http\Responses\SseResponse;
+use App\Framework\Http\Responses\StreamResponse;
+use App\Framework\Http\Responses\WebSocketResponse;
+use App\Framework\Http\Responses\AdaptiveStreamResponse;
+use App\Framework\Http\Streaming\MimeTypeDetector;
+use App\Framework\Http\Streaming\StreamingFormat;
+
+final readonly class ResponseTypeDetector
+{
+    public function detect(Response $response): ResponseType
+    {
+        if($response instanceof SseResponse) {
+            return ResponseType::SSE;
+        }
+
+        if($response instanceof WebsocketResponse) {
+            return ResponseType::WEBSOCKET;
+        }
+
+        if($response instanceof AdaptiveStreamResponse) {
+            return match ($response->format) {
+                StreamingFormat::HLS => ResponseType::HLS,
+                StreamingFormat::DASH => ResponseType::DASH
+            };
+        }
+
+        if($response instanceof StreamResponse) {
+            return ResponseType::MEDIA_STREAM;
+        }
+
+        return $this->detectFromHeaders($response->headers);
+    }
+
+    private function detectFromHeaders(Headers $headers): ResponseType
+    {
+        if($this->isSseResponse($headers)) {
+            return ResponseType::SSE;
+        }
+
+        if($this->isWebSocketResponse($headers)) {
+            return ResponseType::WEBSOCKET;
+        }
+
+        $contentType = $headers->getFirst('Content-Type');
+
+        // HLS-Erkennung
+        if ($contentType === 'application/vnd.apple.mpegurl' ||
+            str_contains($contentType ?? '', 'mpegurl')) {
+            return ResponseType::HLS;
+        }
+
+        // DASH-Erkennung
+        if ($contentType === 'application/dash+xml' ||
+            str_contains($contentType ?? '', 'dash+xml')) {
+            return ResponseType::DASH;
+        }
+
+        if(MimeTypeDetector::isStreamable($contentType ?? '')) {
+            return ResponseType::MEDIA_STREAM;
+        }
+
+        return ResponseType::HTTP;
+    }
+
+    private function isSseResponse(Headers $headers): bool
+    {
+        $contentType = $headers->getFirst('Content-Type');
+
+        return $contentType === 'text/event-stream' ||
+            str_starts_with($contentType ?? '', 'text/event-stream');
+    }
+
+    private function isWebSocketResponse(Headers $headers): bool
+    {
+        $connection = strtolower($headers->getFirst('Connection') ?? '');
+        $upgrade = strtolower($headers->getFirst('Upgrade') ?? '');
+
+        return $connection === 'upgrade' && $upgrade === 'websocket';
+    }
+
+}
diff --git a/src/Framework/Http/Responses/AdaptiveStreamResponse.php b/src/Framework/Http/Responses/AdaptiveStreamResponse.php
new file mode 100644
index 00000000..c0336658
--- /dev/null
+++ b/src/Framework/Http/Responses/AdaptiveStreamResponse.php
@@ -0,0 +1,45 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Http\Responses;
+
+use App\Framework\Http\HeaderKey;
+use App\Framework\Http\Response;
+use App\Framework\Http\Status;
+use App\Framework\Http\Headers;
+use App\Framework\Http\Streaming\AdaptivePlaylist;
+use App\Framework\Http\Streaming\StreamingFormat;
+
+final readonly class AdaptiveStreamResponse implements Response, Streamable
+{
+    public string $body;
+
+    public Headers $headers;
+
+    public function __construct(
+        public AdaptivePlaylist $playlist,
+        public Status $status = Status::OK,
+        Headers $headers = new Headers(),
+
+        public StreamingFormat $format = StreamingFormat::HLS
+    ) {
+        $this->body = $this->playlist->generate($this->format);
+
+        $this->headers = $headers
+                            ->with(HeaderKey::CACHE_CONTROL, 'max-age=60', )
+                            ->with(HeaderKey::ACCESS_CONTROL_ALLOW_ORIGIN, '*' )
+                            ->with(HeaderKey::ACCESS_CONTROL_ALLOW_METHODS, 'GET, HEAD, OPTIONS')
+                            ->with(HeaderKey::ACCESS_CONTROL_ALLOW_HEADERS, 'RANGE' );
+
+        // Format-spezifische Header setzen
+        #$this->headers = $this->headers->with('Content-Type', $this->format->getContentType());
+
+        // Standard Streaming-Header
+        #$this->headers = $this->headers
+        #    ->with('Cache-Control', 'max-age=60')
+        #    ->with('Access-Control-Allow-Origin', '*')
+        #    ->with('Access-Control-Allow-Methods', 'GET, HEAD, OPTIONS')
+        #    ->with('Access-Control-Allow-Headers', 'Range');
+    }
+}
diff --git a/src/Framework/Http/Responses/JsonResponse.php b/src/Framework/Http/Responses/JsonResponse.php
new file mode 100644
index 00000000..f3f0b4fa
--- /dev/null
+++ b/src/Framework/Http/Responses/JsonResponse.php
@@ -0,0 +1,22 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Http\Responses;
+
+use App\Framework\Http\Headers;
+use App\Framework\Http\Response;
+use App\Framework\Http\Status;
+
+final readonly class JsonResponse implements Response
+{
+    public Headers $headers;
+
+    public string $body;
+    public function __construct(
+        array $body = [],
+        public Status $status = Status::OK,
+    ) {
+        $this->headers = new Headers()->with('Content-Type', 'application/json');
+        $this->body = json_encode($body);
+    }
+}
diff --git a/src/Framework/Http/Responses/MediaType.php b/src/Framework/Http/Responses/MediaType.php
new file mode 100644
index 00000000..a23ab629
--- /dev/null
+++ b/src/Framework/Http/Responses/MediaType.php
@@ -0,0 +1,21 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Http\Responses;
+
+enum MediaType: string
+{
+    case VIDEO = 'video';
+    case AUDIO = 'audio';
+    case UNKNOWN = 'unknown';
+
+
+    public static function fromMimeType(string $mimeType): self
+    {
+        return match (true) {
+            str_starts_with($mimeType, 'video/') => self::VIDEO,
+            str_starts_with($mimeType, 'audio/') => self::AUDIO,
+            default => self::UNKNOWN
+        };
+    }
+}
diff --git a/src/Framework/Http/Responses/NotFound.php b/src/Framework/Http/Responses/NotFound.php
new file mode 100644
index 00000000..d3ac5910
--- /dev/null
+++ b/src/Framework/Http/Responses/NotFound.php
@@ -0,0 +1,20 @@
+<?php
+
+namespace App\Framework\Http\Responses;
+
+use App\Framework\Http\Headers;
+use App\Framework\Http\Response;
+use App\Framework\Http\Status;
+
+final readonly class NotFound implements Response
+{
+    public Status $status;
+    public Headers $headers;
+
+    public function __construct(
+        public string $body = 'Not Found',
+    ) {
+        $this->status = Status::NOT_FOUND;
+        $this->headers = new Headers();
+    }
+}
diff --git a/src/Framework/Http/Responses/Redirect.php b/src/Framework/Http/Responses/Redirect.php
deleted file mode 100644
index 7fdc72be..00000000
--- a/src/Framework/Http/Responses/Redirect.php
+++ /dev/null
@@ -1,18 +0,0 @@
-<?php
-
-namespace App\Framework\Http\Responses;
-
-use App\Framework\Http\Headers;
-use App\Framework\Http\Response;
-use App\Framework\Http\Status;
-
-class Redirect implements Response
-{
-    public private(set) string $body = '';
-    public private(set) Status $status = Status::FOUND;
-    public \App\Framework\Http\Headers $headers {
-        get {
-            return new Headers()->with('Location', $this->body);
-        }
-    }
-}
diff --git a/src/Framework/Http/Responses/RedirectResponse.php b/src/Framework/Http/Responses/RedirectResponse.php
new file mode 100644
index 00000000..3e6fffbf
--- /dev/null
+++ b/src/Framework/Http/Responses/RedirectResponse.php
@@ -0,0 +1,24 @@
+<?php
+
+namespace App\Framework\Http\Responses;
+
+use App\Framework\Http\HeaderKey;
+use App\Framework\Http\Headers;
+use App\Framework\Http\Response;
+use App\Framework\Http\Status;
+use App\Framework\Http\Uri;
+
+final readonly class RedirectResponse implements Response
+{
+    public Headers $headers;
+    public string $body;
+    public Status $status;
+
+    public function __construct(
+        public Uri $location = new Uri('/'),
+    ) {
+        $this->status = Status::FOUND;
+        $this->body = '';
+        $this->headers = new Headers()->with(HeaderKey::LOCATION, (string)$this->location);
+    }
+}
diff --git a/src/Framework/Http/Responses/SseResponse.php b/src/Framework/Http/Responses/SseResponse.php
new file mode 100644
index 00000000..28637c69
--- /dev/null
+++ b/src/Framework/Http/Responses/SseResponse.php
@@ -0,0 +1,71 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Http\Responses;
+
+use App\Framework\Http\Headers;
+use App\Framework\Http\Response;
+use App\Framework\Http\Status;
+use App\Framework\Router\Result\SseEvent;
+use App\Framework\Router\Result\SseResult;
+use App\Framework\Router\Result\SseResultWithCallback;
+use Closure;
+
+/**
+ * Response-Klasse für Server-Sent Events
+ */
+final class SseResponse implements Response, Streamable
+{
+    public readonly Status $status;
+    public readonly Headers $headers;
+    public readonly string $body;
+
+    public array $initialEvents = [];
+
+    /**
+     * @var int Maximale Streaming-Dauer in Sekunden (0 = unbegrenzt)
+     */
+    public readonly int $maxDuration;
+
+    /**
+     * @var int Intervall für Heartbeats in Sekunden
+     */
+    public readonly int $heartbeatInterval;
+
+    /**
+     * @param SseResult $sseResult Das SseResult, aus dem die Response erstellt wird
+     * @param Closure|null $streamCallback
+     */
+    public function __construct(SseResult $sseResult, public readonly ?Closure $streamCallback = null)
+    {
+        $this->status = $sseResult->status;
+
+        $this->body = '';
+
+        // Standard SSE-Header
+        $headerData = [
+            'Content-Type' => 'text/event-stream',
+            'Cache-Control' => 'no-cache',
+            'Connection' => 'keep-alive',
+            'X-Accel-Buffering' => 'no', // Nginx buffering deaktivieren
+        ];
+
+        // Benutzerdefinierte Header hinzufügen
+        foreach ($sseResult->headers as $name => $value) {
+            $headerData[$name] = $value;
+        }
+
+        $this->headers = new Headers($headerData);
+
+        // Initiale Events aus dem SseResult speichern
+        $this->initialEvents = $sseResult->getInitialEvents();
+
+        // Globales Retry-Interval setzen, falls definiert
+        if ($sseResult->retryInterval !== null) {
+            $this->initialEvents[] = new SseEvent('', null, null, $sseResult->retryInterval);
+        }
+
+        $this->maxDuration = $sseResult->maxDuration;
+        $this->heartbeatInterval = $sseResult->heartbeatInterval;;
+    }
+}
diff --git a/src/Framework/Http/Responses/StreamResponse.php b/src/Framework/Http/Responses/StreamResponse.php
new file mode 100644
index 00000000..6e8d8845
--- /dev/null
+++ b/src/Framework/Http/Responses/StreamResponse.php
@@ -0,0 +1,29 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Http\Responses;
+
+use App\Framework\Http\Headers;
+use App\Framework\Http\Range;
+use App\Framework\Http\Response;
+use App\Framework\Http\Status;
+
+final readonly class StreamResponse implements Response, Streamable
+{
+
+    public string $body;
+
+    public function __construct(
+        public Status  $status = Status::OK,
+        public Headers $headers = new Headers(),
+        #public mixed $fileContent,
+
+        public string  $filePath = '',
+        public int $fileSize = 0,
+        public string $mimeType = 'application/octet-stream',
+        public ?Range   $range = null,
+        public MediaType $mediaType = MediaType::UNKNOWN,
+    ) {
+        $this->body = '';
+    }
+}
diff --git a/src/Framework/Http/Responses/Streamable.php b/src/Framework/Http/Responses/Streamable.php
new file mode 100644
index 00000000..9122029b
--- /dev/null
+++ b/src/Framework/Http/Responses/Streamable.php
@@ -0,0 +1,8 @@
+<?php
+
+namespace App\Framework\Http\Responses;
+
+interface Streamable
+{
+
+}
diff --git a/src/Framework/Http/Responses/WebSocketResponse.php b/src/Framework/Http/Responses/WebSocketResponse.php
new file mode 100644
index 00000000..1cd3a727
--- /dev/null
+++ b/src/Framework/Http/Responses/WebSocketResponse.php
@@ -0,0 +1,59 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Http\Responses;
+
+use App\Framework\Http\Headers;
+use App\Framework\Http\Response;
+use App\Framework\Http\Status;
+use App\Framework\Router\Result\WebSocketResult;
+
+/**
+ * Response-Klasse für WebSocket-Upgrade
+ */
+final readonly class WebSocketResponse implements Response, Streamable
+{
+    public Status $status;
+    public Headers $headers;
+    public string $body;
+
+    public function __construct(
+        private WebSocketResult $webSocketResult,
+        private string          $websocketKey
+    ) {
+        $this->status = $webSocketResult->status;
+
+        // WebSocket-Upgrade-Header
+        $headerData = [
+            'Upgrade' => 'websocket',
+            'Connection' => 'Upgrade',
+            'Sec-WebSocket-Accept' => $this->generateAcceptKey($this->websocketKey),
+        ];
+
+        // Subprotokoll hinzufügen, falls unterstützt
+        $subprotocols = $webSocketResult->getSubprotocols();
+        if (!empty($subprotocols)) {
+            $headerData['Sec-WebSocket-Protocol'] = implode(', ', $subprotocols);
+        }
+
+        // Benutzerdefinierte Header hinzufügen
+        foreach ($webSocketResult->headers as $name => $value) {
+            $headerData[$name] = $value;
+        }
+
+        $this->headers = new Headers($headerData);
+    }
+
+    /**
+     * Generiert den Accept-Key für WebSocket-Handshake
+     */
+    private function generateAcceptKey(string $key): string
+    {
+        return base64_encode(hash('sha1', $key . '258EAFA5-E914-47DA-95CA-C5AB0DC85B11', true));
+    }
+
+    public function getWebSocketResult(): WebSocketResult
+    {
+        return $this->webSocketResult;
+    }
+}
diff --git a/src/Framework/Http/ServerEnvironment.php b/src/Framework/Http/ServerEnvironment.php
new file mode 100644
index 00000000..13d33afb
--- /dev/null
+++ b/src/Framework/Http/ServerEnvironment.php
@@ -0,0 +1,184 @@
+<?php
+
+namespace App\Framework\Http;
+
+/**
+ * Kapselt Server-Environment-Daten aus $_SERVER
+ */
+final readonly class ServerEnvironment
+{
+    public function __construct(
+        private array $serverData = []
+    ) {}
+
+    public static function fromGlobals(): self
+    {
+        return new self($_SERVER);
+    }
+
+    public function get(string|ServerKey $key, mixed $default = null): mixed
+    {
+        if($key instanceof ServerKey) {
+            $key = $key->value;
+        }
+
+        return $this->serverData[$key] ?? $default;
+    }
+
+    public function has(string|ServerKey $key): bool
+    {
+        !$key instanceof ServerKey ?: $key = $key->value;
+
+        return array_key_exists($key, $this->serverData);
+    }
+
+    // Häufig verwendete Server-Informationen als typisierte Methoden
+    public function getRemoteAddr(): IpAddress
+    {
+        $ip = $this->get(ServerKey::REMOTE_ADDR, '0.0.0.0');
+        return new IpAddress($ip);
+    }
+
+    public function getUserAgent(): string
+    {
+        return $this->get(ServerKey::HTTP_USER_AGENT, '');
+    }
+
+    public function getServerName(): string
+    {
+        return $this->get(ServerKey::SERVER_NAME, '');
+    }
+
+    public function getServerPort(): int
+    {
+        return (int) $this->get(ServerKey::SERVER_PORT, 80);
+    }
+
+    public function getRequestUri(): Uri
+    {
+        $uriString = $this->get(ServerKey::REQUEST_URI, '/');
+        return new Uri($uriString);
+    }
+
+    public function getScriptName(): string
+    {
+        return $this->get(ServerKey::SCRIPT_NAME, '');
+    }
+
+    public function getHttpHost(): string
+    {
+        return $this->get(ServerKey::HTTP_HOST, '');
+    }
+
+    public function isHttps(): bool
+    {
+        return $this->get(ServerKey::HTTPS) === 'on' ||
+            $this->get(ServerKey::SERVER_PORT) === '443' ||
+            $this->get(ServerKey::HTTP_X_FORWARDED_PROTO) === 'https';
+    }
+
+    public function getRequestMethod(): Method
+    {
+        $methodString = $this->get(ServerKey::REQUEST_METHOD, 'GET');
+        return Method::tryFrom($methodString) ?? Method::GET;
+
+    }
+
+    public function getQueryString(): string
+    {
+        return $this->get(ServerKey::QUERY_STRING, '');
+    }
+
+    public function getClientIp(): IpAddress
+    {
+        return new IpAddress($this->getClientIpString());
+    }
+
+    public function getProtocol(): ServerProtocol
+    {
+        $protocol = $this->get(ServerKey::SERVER_PROTOCOL);
+        return ServerProtocol::tryFrom($protocol) ?? ServerProtocol::HTTP_1_0;
+    }
+
+    private function getClientIpString(): string
+    {
+        // Priorisierte IP-Erkennung
+        $candidates = [
+            ServerKey::HTTP_X_REAL_IP,
+            ServerKey::HTTP_X_FORWARDED_FOR,
+            ServerKey::REMOTE_ADDR
+        ];
+
+        foreach ($candidates as $key) {
+            $ip = $this->get($key);
+            if ($ip) {
+                // Bei X-Forwarded-For kann es mehrere IPs geben
+                if ($key === ServerKey::HTTP_X_FORWARDED_FOR) {
+                    $ips = explode(',', $ip);
+                    return trim($ips[0]);
+                }
+                return $ip;
+            }
+        }
+
+        return '0.0.0.0';
+    }
+
+    public function getReferer(): string
+    {
+        return $this->get(ServerKey::HTTP_REFERER, '');
+    }
+
+    public function getRefererUri(): Uri
+    {
+        $referer = $this->getReferer();
+
+        return new Uri($referer);
+    }
+
+    /**
+     * Prüft ob ein Referer gesetzt ist
+     */
+    public function hasReferer(): bool
+    {
+        return !empty($this->get(ServerKey::HTTP_REFERER, null));
+    }
+
+    /**
+     * Prüft ob der Referer von der gleichen Domain stammt
+     */
+    public function isRefererSameDomain(): bool
+    {
+        $referer = $this->getReferer();
+
+        if (empty($referer)) {
+            return false;
+        }
+
+        $refererHost = parse_url($referer, PHP_URL_HOST);
+        $currentHost = $this->getHttpHost();
+
+        return $refererHost === $currentHost;
+    }
+
+    /**
+     * Sichere Referer-URL für Redirects
+     */
+    public function getSafeRefererUrl(string $fallback = '/'): string
+    {
+        $referer = $this->getReferer();
+
+        // Kein Referer gesetzt
+        if (empty($referer)) {
+            return $fallback;
+        }
+
+        // Nur interne Referer erlauben (CSRF-Schutz)
+        if (!$this->isRefererSameDomain()) {
+            return $fallback;
+        }
+
+        return $referer;
+    }
+
+}
diff --git a/src/Framework/Http/ServerKey.php b/src/Framework/Http/ServerKey.php
new file mode 100644
index 00000000..2523d465
--- /dev/null
+++ b/src/Framework/Http/ServerKey.php
@@ -0,0 +1,58 @@
+<?php
+
+namespace App\Framework\Http;
+
+/**
+ * Enum für $_SERVER-Array-Keys
+ * Bietet Typsicherheit und IDE-Unterstützung für Server-Variablen
+ */
+enum ServerKey: string
+{
+    // Request-Informationen
+    case REQUEST_METHOD = 'REQUEST_METHOD';
+    case REQUEST_URI = 'REQUEST_URI';
+    case QUERY_STRING = 'QUERY_STRING';
+    case REQUEST_SCHEME = 'REQUEST_SCHEME';
+
+    // Server-Informationen
+    case SERVER_NAME = 'SERVER_NAME';
+    case SERVER_PORT = 'SERVER_PORT';
+    case SERVER_PROTOCOL = 'SERVER_PROTOCOL';
+    case SCRIPT_NAME = 'SCRIPT_NAME';
+    case DOCUMENT_ROOT = 'DOCUMENT_ROOT';
+
+    // Client-Informationen
+    case REMOTE_ADDR = 'REMOTE_ADDR';
+    case REMOTE_HOST = 'REMOTE_HOST';
+    case REMOTE_PORT = 'REMOTE_PORT';
+    case REMOTE_USER = 'REMOTE_USER';
+
+    // HTTP-Header (als SERVER-Variablen)
+    case HTTP_HOST = 'HTTP_HOST';
+    case HTTP_USER_AGENT = 'HTTP_USER_AGENT';
+    case HTTP_ACCEPT = 'HTTP_ACCEPT';
+    case HTTP_ACCEPT_LANGUAGE = 'HTTP_ACCEPT_LANGUAGE';
+    case HTTP_ACCEPT_ENCODING = 'HTTP_ACCEPT_ENCODING';
+    case HTTP_CONNECTION = 'HTTP_CONNECTION';
+    case HTTP_REFERER = 'HTTP_REFERER';
+    case HTTP_AUTHORIZATION = 'HTTP_AUTHORIZATION';
+    case HTTP_X_FORWARDED_FOR = 'HTTP_X_FORWARDED_FOR';
+    case HTTP_X_FORWARDED_PROTO = 'HTTP_X_FORWARDED_PROTO';
+    case HTTP_X_REAL_IP = 'HTTP_X_REAL_IP';
+
+    // HTTPS und Sicherheit
+    case HTTPS = 'HTTPS';
+    case SSL_PROTOCOL = 'SSL_PROTOCOL';
+
+    // CGI/FastCGI-spezifisch
+    case GATEWAY_INTERFACE = 'GATEWAY_INTERFACE';
+    case SERVER_SOFTWARE = 'SERVER_SOFTWARE';
+
+    // Pfad-Informationen
+    case PATH_INFO = 'PATH_INFO';
+    case PATH_TRANSLATED = 'PATH_TRANSLATED';
+
+    // Content-Informationen
+    case CONTENT_LENGTH = 'CONTENT_LENGTH';
+    case CONTENT_TYPE = 'CONTENT_TYPE';
+}
diff --git a/src/Framework/Http/ServerProtocol.php b/src/Framework/Http/ServerProtocol.php
new file mode 100644
index 00000000..60a9fcd1
--- /dev/null
+++ b/src/Framework/Http/ServerProtocol.php
@@ -0,0 +1,10 @@
+<?php
+
+namespace App\Framework\Http;
+
+enum ServerProtocol: string
+{
+    case HTTP_1_0 = "HTTP/1.0";
+    case HTTP_1_1 = "HTTP/1.1";
+    case HTTP_2_0 = "HTTP/2.0";
+}
diff --git a/src/Framework/Http/Session/CsrfProtection.php b/src/Framework/Http/Session/CsrfProtection.php
new file mode 100644
index 00000000..b3869a81
--- /dev/null
+++ b/src/Framework/Http/Session/CsrfProtection.php
@@ -0,0 +1,97 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Http\Session;
+
+final readonly class CsrfProtection
+{
+    private const int TOKEN_LIFETIME = 3600; //1h
+    private const int MAX_TOKENS_PER_FORM = 3;
+
+    private Session $session;
+
+    public function __construct(Session $session)
+    {
+        $this->session = $session;
+
+        // Sicherstellen, dass CSRF-Bereich existiert
+        if (!$this->session->has(SessionKey::CSRF->value)) {
+            $this->session->set(SessionKey::CSRF->value, []);
+        }
+    }
+
+    public function generateToken(string $formId): string
+    {
+        $token = bin2hex(random_bytes(32));
+        $csrf = $this->session->get(SessionKey::CSRF->value, []);
+
+        if (!isset($csrf[$formId])) {
+            $csrf[$formId] = [];
+        }
+
+        $csrf[$formId][] = [
+            'token' => $token,
+            'created_at' => time()
+        ];
+
+        $csrf[$formId] = $this->cleanupOldTokens($csrf[$formId]);
+
+        $this->session->set(SessionKey::CSRF->value, $csrf);
+
+        return $token;
+    }
+
+    public function validateToken(string $formId, string $token): bool
+    {
+        $csrf = $this->session->get(SessionKey::CSRF->value, []);
+
+        if (!isset($csrf[$formId])) {
+            return false;
+        }
+
+        foreach ($csrf[$formId] as $index => $tokenData) {
+            if ($tokenData['token'] === $token) {
+                // Token ist gültig - NICHT löschen, nur als "used" markieren
+                $csrf[$formId][$index]['used_at'] = time();
+                $this->session->set(SessionKey::CSRF->value, $csrf);
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    private function cleanupOldTokens(array $tokens): array
+    {
+        $now = time();
+        $cleaned = [];
+
+        foreach ($tokens as $tokenData) {
+            // Behalte Token die:
+            // 1. Noch nicht abgelaufen sind
+            // 2. Kürzlich verwendet wurden (für Re-Submits)
+            $age = $now - $tokenData['created_at'];
+            $usedRecently = isset($tokenData['used_at']) &&
+                ($now - $tokenData['used_at']) < 300; // 5 Minuten
+
+            if ($age < self::TOKEN_LIFETIME || $usedRecently) {
+                $cleaned[] = $tokenData;
+            }
+        }
+
+        // Behalte nur die neuesten N Tokens
+        return array_slice($cleaned, -self::MAX_TOKENS_PER_FORM);
+    }
+
+    // Diese Methode nur für spezielle Fälle behalten (z.B. AJAX)
+    /*public function renderHiddenFields(string $formId): string
+    {
+        $token = $this->generateToken($formId);
+        return sprintf(
+            '<input type="hidden" name="_token" value="%s"><input type="hidden" name="_form_id" value="%s">',
+            htmlspecialchars($token),
+            htmlspecialchars($formId)
+        );
+    }*/
+}
diff --git a/src/Framework/Http/Session/Events/CsrfTokenGeneratedEvent.php b/src/Framework/Http/Session/Events/CsrfTokenGeneratedEvent.php
new file mode 100644
index 00000000..cb082306
--- /dev/null
+++ b/src/Framework/Http/Session/Events/CsrfTokenGeneratedEvent.php
@@ -0,0 +1,15 @@
+<?php
+
+namespace App\Framework\Http\Session\Events;
+
+use App\Framework\Http\Session\SessionId;
+
+final readonly class CsrfTokenGeneratedEvent
+{
+    public function __construct(
+        public SessionId $sessionId,
+        public string $formId,
+        public string $token,
+        public int $timestamp
+    ){}
+}
diff --git a/src/Framework/Http/Session/Events/CsrfTokenValidatedEvent.php b/src/Framework/Http/Session/Events/CsrfTokenValidatedEvent.php
new file mode 100644
index 00000000..98efdd62
--- /dev/null
+++ b/src/Framework/Http/Session/Events/CsrfTokenValidatedEvent.php
@@ -0,0 +1,16 @@
+<?php
+
+namespace App\Framework\Http\Session\Events;
+
+use App\Framework\Http\Session\SessionId;
+
+final readonly class CsrfTokenValidatedEvent
+{
+    public function __construct(
+        public SessionId $sessionId,
+        public string $formId,
+        public string $token,
+        public bool $isValid,
+        public int $timestamp
+    ){}
+}
diff --git a/src/Framework/Http/Session/Events/FlashMessageAddedEvent.php b/src/Framework/Http/Session/Events/FlashMessageAddedEvent.php
new file mode 100644
index 00000000..586fb54a
--- /dev/null
+++ b/src/Framework/Http/Session/Events/FlashMessageAddedEvent.php
@@ -0,0 +1,15 @@
+<?php
+
+namespace App\Framework\Http\Session\Events;
+
+use App\Framework\Http\Session\SessionId;
+
+final readonly class FlashMessageAddedEvent
+{
+    public function __construct(
+        public SessionId $sessionId,
+        public string $type,
+        public string $message,
+        public int $timestamp
+    ){}
+}
diff --git a/src/Framework/Http/Session/Events/FlashMessageRemovedEvent.php b/src/Framework/Http/Session/Events/FlashMessageRemovedEvent.php
new file mode 100644
index 00000000..2f5f4081
--- /dev/null
+++ b/src/Framework/Http/Session/Events/FlashMessageRemovedEvent.php
@@ -0,0 +1,15 @@
+<?php
+
+namespace App\Framework\Http\Session\Events;
+
+use App\Framework\Http\Session\SessionId;
+
+final readonly class FlashMessageRemovedEvent
+{
+    public function __construct(
+        public SessionId $sessionId,
+        public string $type,
+        public string $message,
+        public int $timestamp
+    ){}
+}
diff --git a/src/Framework/Http/Session/Events/SessionClearedEvent.php b/src/Framework/Http/Session/Events/SessionClearedEvent.php
new file mode 100644
index 00000000..c01f0145
--- /dev/null
+++ b/src/Framework/Http/Session/Events/SessionClearedEvent.php
@@ -0,0 +1,14 @@
+<?php
+
+namespace App\Framework\Http\Session\Events;
+
+use App\Framework\Http\Session\SessionId;
+
+final readonly class SessionClearedEvent
+{
+    public function __construct(
+        public SessionId $sessionId,
+        public array $oldData,
+        public int $timestamp
+    ){}
+}
diff --git a/src/Framework/Http/Session/Events/SessionDataChangedEvent.php b/src/Framework/Http/Session/Events/SessionDataChangedEvent.php
new file mode 100644
index 00000000..37fef439
--- /dev/null
+++ b/src/Framework/Http/Session/Events/SessionDataChangedEvent.php
@@ -0,0 +1,16 @@
+<?php
+
+namespace App\Framework\Http\Session\Events;
+
+use App\Framework\Http\Session\SessionId;
+
+final readonly class SessionDataChangedEvent
+{
+    public function __construct(
+        public SessionId $sessionId,
+        public string $key,
+        public mixed $oldValue,
+        public mixed $newValue,
+        public int $timestamp
+    ){}
+}
diff --git a/src/Framework/Http/Session/Events/SessionDataRemovedEvent.php b/src/Framework/Http/Session/Events/SessionDataRemovedEvent.php
new file mode 100644
index 00000000..7da83e0e
--- /dev/null
+++ b/src/Framework/Http/Session/Events/SessionDataRemovedEvent.php
@@ -0,0 +1,15 @@
+<?php
+
+namespace App\Framework\Http\Session\Events;
+
+use App\Framework\Http\Session\SessionId;
+
+final readonly class SessionDataRemovedEvent
+{
+    public function __construct(
+        public SessionId $sessionId,
+        public string $key,
+        public mixed $oldValue,
+        public int $timestamp
+    ){}
+}
diff --git a/src/Framework/Http/Session/Events/SessionInvalidatedEvent.php b/src/Framework/Http/Session/Events/SessionInvalidatedEvent.php
new file mode 100644
index 00000000..c22093dd
--- /dev/null
+++ b/src/Framework/Http/Session/Events/SessionInvalidatedEvent.php
@@ -0,0 +1,15 @@
+<?php
+
+namespace App\Framework\Http\Session\Events;
+
+use App\Framework\Http\Session\SessionId;
+
+final readonly class SessionInvalidatedEvent
+{
+    public function __construct(
+        public SessionId $sessionId,
+        public string $reason,
+        public array $securityData,
+        public int $timestamp
+    ){}
+}
diff --git a/src/Framework/Http/Session/Events/SessionRegeneratedEvent.php b/src/Framework/Http/Session/Events/SessionRegeneratedEvent.php
new file mode 100644
index 00000000..1f538803
--- /dev/null
+++ b/src/Framework/Http/Session/Events/SessionRegeneratedEvent.php
@@ -0,0 +1,15 @@
+<?php
+
+namespace App\Framework\Http\Session\Events;
+
+use App\Framework\Http\Session\SessionId;
+
+final readonly class SessionRegeneratedEvent
+{
+    public function __construct(
+        public SessionId $sessionId,
+        public SessionId $oldSessionId,
+        public string $reason,
+        public int $timestamp
+    ){}
+}
diff --git a/src/Framework/Http/Session/FlashBag.php b/src/Framework/Http/Session/FlashBag.php
new file mode 100644
index 00000000..a6e8ac4b
--- /dev/null
+++ b/src/Framework/Http/Session/FlashBag.php
@@ -0,0 +1,83 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Http\Session;
+
+/**
+ * The FlashBag class provides a mechanism to manage flash messages in a session,
+ * typically used for temporary notifications such as success messages, error alerts,
+ * or other transient data between requests.
+ */
+final class FlashBag
+{
+    private array $newFlashData = [];
+
+    public function __construct(
+        private Session $session
+    ){
+        $this->session = $session;
+
+        // Sicherstellen, dass Flash-Bereich existiert
+        if (!$this->session->has(SessionKey::FLASH->value)) {
+            $this->session->set(SessionKey::FLASH->value, []);
+        }
+    }
+
+    public function add(string $type, string $message): void
+    {
+        $flashData = $this->session->get(SessionKey::FLASH->value, []);
+
+        if (!isset($flashData[$type])) {
+            $flashData[$type] = [];
+        }
+
+        $flashData[$type][] = $message;
+        $this->session->set(SessionKey::FLASH->value, $flashData);
+    }
+
+    public function get(string $type): array
+    {
+        $flashData = $this->session->get(SessionKey::FLASH->value, []);
+        $messages = $flashData[$type] ?? [];
+
+        // Nur für diesen spezifischen Typ löschen
+        if (isset($flashData[$type])) {
+            unset($flashData[$type]);
+            $this->session->set(SessionKey::FLASH->value, $flashData);
+        }
+
+        return $messages;
+    }
+
+    public function has(string $type): bool
+    {
+        $flashData = $this->session->get(SessionKey::FLASH->value, []);
+        return !empty($flashData[$type]);
+    }
+
+    public function all(): array
+    {
+        $flashData = $this->session->get(SessionKey::FLASH->value, []);
+        $this->session->set(SessionKey::FLASH->value, []);
+
+        return $flashData;
+    }
+
+    public function keep(string $type): void
+    {
+        if ($this->has($type)) {
+            $this->newFlashData[$type] = $this->session->get(SessionKey::FLASH->value)[$type];
+        }
+    }
+
+    public function keepAll(): void
+    {
+        $this->newFlashData = $this->session->get(SessionKey::FLASH->value, []);
+    }
+
+    public function age(): void
+    {
+        $this->session->set(SessionKey::FLASH->value, $this->newFlashData);
+        $this->newFlashData = [];
+    }
+}
diff --git a/src/Framework/Http/Session/FormDataStorage.php b/src/Framework/Http/Session/FormDataStorage.php
new file mode 100644
index 00000000..edc8f16c
--- /dev/null
+++ b/src/Framework/Http/Session/FormDataStorage.php
@@ -0,0 +1,61 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Http\Session;
+
+/**
+ * This class provides functionality to store, retrieve, and manage form data
+ * in a session-based storage.
+ */
+final readonly class FormDataStorage
+{
+    public function __construct(
+        private Session $session
+    ){
+        // Sicherstellen, dass Formulardatenbereich existiert
+        if (!$this->session->has(SessionKey::FORM_DATA->value)) {
+            $this->session->set(SessionKey::FORM_DATA->value, []);
+        }
+    }
+
+    public function store(string $formId, array $data): void
+    {
+        $formData = $this->session->get(SessionKey::FORM_DATA->value, []);
+        $formData[$formId] = $data;
+        $this->session->set(SessionKey::FORM_DATA->value, $formData);
+    }
+
+    public function get(string $formId): array
+    {
+        $formData = $this->session->get(SessionKey::FORM_DATA->value, []);
+        return $formData[$formId] ?? [];
+    }
+
+    public function getField(string $formId, string $field, $default = null)
+    {
+        $data = $this->get($formId);
+        return $data[$field] ?? $default;
+    }
+
+    public function has(string $formId): bool
+    {
+        $formData = $this->session->get(SessionKey::FORM_DATA->value, []);
+        return !empty($formData[$formId]);
+    }
+
+    public function clear(string $formId): void
+    {
+        $formData = $this->session->get(SessionKey::FORM_DATA->value, []);
+
+        if (isset($formData[$formId])) {
+            unset($formData[$formId]);
+            $this->session->set(SessionKey::FORM_DATA->value, $formData);
+        }
+    }
+
+    public function clearAll(): void
+    {
+        $this->session->set(SessionKey::FORM_DATA->value, []);
+    }
+}
diff --git a/src/Framework/Http/Session/RandomBytesSessionIdGenerator.php b/src/Framework/Http/Session/RandomBytesSessionIdGenerator.php
new file mode 100644
index 00000000..a39474f5
--- /dev/null
+++ b/src/Framework/Http/Session/RandomBytesSessionIdGenerator.php
@@ -0,0 +1,23 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Http\Session;
+
+final readonly class RandomBytesSessionIdGenerator implements SessionIdGenerator
+{
+    public function __construct(
+        private int $length = 32
+    ) {
+    }
+
+    public function generate(): SessionId
+    {
+        return SessionId::fromString(bin2hex(random_bytes($this->length)));
+    }
+
+    public function isValid(SessionId $id): bool
+    {
+        $idString = $id->toString();
+        return strlen($idString) === $this->length * 2 && ctype_xdigit($idString);
+    }
+}
diff --git a/src/Framework/Http/Session/RedisSessionStorage.php b/src/Framework/Http/Session/RedisSessionStorage.php
new file mode 100644
index 00000000..0862f3c6
--- /dev/null
+++ b/src/Framework/Http/Session/RedisSessionStorage.php
@@ -0,0 +1,64 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Http\Session;
+
+use Predis\Client;
+
+/**
+ * Implementation of the SessionStorage interface using Redis as the storage backend.
+ * This class provides methods to read, write, remove, and migrate session data stored in Redis.
+ */
+final class RedisSessionStorage implements SessionStorage
+{
+    private const string PREFIX = 'session:';
+
+    public function __construct(
+        private readonly Client $redis = new Client([
+            'scheme' => 'tcp',
+            'host' => 'redis',
+            'port' => 6379,
+            'parameters' => []
+        ]),
+        private readonly int $ttl = 3600 // 1 Stunde standardmäßig
+    ) {
+        #$this->redis->connect();
+    }
+
+    public function read(SessionId $id): array
+    {
+        $data = $this->redis->get($this->getKey($id));
+
+        if ($data === null) {
+            return [];
+        }
+
+        return json_decode($data, true) ?? [];
+    }
+
+    public function write(SessionId $id, array $data): void
+    {
+        $this->redis->setex(
+            $this->getKey($id),
+            $this->ttl,
+            json_encode($data)
+        );
+    }
+
+    public function remove(SessionId $id): void
+    {
+        $this->redis->del($this->getKey($id));
+    }
+
+    public function migrate(SessionId $fromId, SessionId $toId): void
+    {
+        $data = $this->read($fromId);
+        $this->write($toId, $data);
+        $this->remove($fromId);
+    }
+
+    private function getKey(SessionId $id): string
+    {
+        return self::PREFIX . $id->toString();
+    }
+}
diff --git a/src/Framework/Http/Session/SecurityManager.php b/src/Framework/Http/Session/SecurityManager.php
new file mode 100644
index 00000000..61ee73de
--- /dev/null
+++ b/src/Framework/Http/Session/SecurityManager.php
@@ -0,0 +1,94 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Http\Session;
+
+use App\Framework\DateTime\Clock;
+use App\Framework\Http\IpAddress;
+
+final readonly class SecurityManager
+{
+    public function __construct(
+        // Muss Privat bleiben: Der SecurityManager ist teil einer übergeordneten Session
+        private Session $session,
+        private Clock $clock,
+        public int $sessionTimeout = 3600,
+        public int $sessionRegenerationInterval = 300
+    ) {}
+
+    private function key(): string
+    {
+        return SessionKey::SECURITY->value;
+    }
+
+    public function initialize(string $userAgent, IpAddress $ipAddress): void
+    {
+        $securityData = new SessionSecurityData(
+                                            $userAgent,
+                                            $ipAddress,
+                                            $this->clock->time(),
+                                            $this->clock->time()
+        );
+
+        $this->session->set($this->key(), $securityData->toArray());
+    }
+
+    public function updateLastActivity(): void
+    {
+        if ($this->session->has($this->key())) {
+            $securityData = SessionSecurityData::fromSession($this->session);
+
+            $updatedData = $securityData->withLastActivity($this->clock->time());
+            $this->session->set($this->key(), $updatedData->toArray());
+        }
+    }
+
+    public function shouldRegenerateId(): bool
+    {
+        if (!$this->session->has($this->key())) {
+            return true;
+        }
+
+        $securityData = SessionSecurityData::fromSession($this->session);
+
+        return ($this->clock->time() - $securityData->lastRegeneration) > $this->sessionRegenerationInterval;
+    }
+
+    public function markRegenerated(): void
+    {
+        if ($this->session->has($this->key())) {
+            $securityData = SessionSecurityData::fromSession($this->session);
+
+            $updatedData = $securityData->withLastRegeneration($this->clock->time());
+            $this->session->set($this->key(), $updatedData->toArray());
+        }
+    }
+
+    public function validate(string $userAgent, IpAddress $ipAddress): bool
+    {
+        if (!$this->session->has($this->key())) {
+            return false;
+        }
+
+        $securityData = SessionSecurityData::fromSession($this->session);
+
+
+        // UserAgent muss übereinstimmen
+        if ($securityData->userAgent !== $userAgent) {
+            return false;
+        }
+
+        // IP-Adressen-Prüfung
+        if ($securityData->ipAddress->value !== $ipAddress->value) {
+            return false;
+        }
+
+        // Timeout-Prüfung
+        if (($this->clock->time() - $securityData->lastActivity) > $this->sessionTimeout) {
+            return false;
+        }
+
+        return true;
+    }
+}
diff --git a/src/Framework/Http/Session/Session.php b/src/Framework/Http/Session/Session.php
new file mode 100644
index 00000000..7ad81e41
--- /dev/null
+++ b/src/Framework/Http/Session/Session.php
@@ -0,0 +1,79 @@
+<?php
+
+namespace App\Framework\Http\Session;
+
+use App\Framework\Attributes\Singleton;
+use App\Framework\DateTime\Clock;
+
+final class Session
+{
+    private array $data = [];
+    #private bool $isStarted = false;
+
+    // Komponenten als Properties
+    public readonly FlashBag $flash;
+    public readonly ValidationErrorBag $validation;
+    public readonly FormDataStorage $form;
+    public readonly SecurityManager $security;
+    public readonly CsrfProtection $csrf;
+
+    public function __construct(
+        public readonly SessionId $id,
+        private readonly Clock $clock,
+    ){
+        #$this->isStarted = true;
+
+        // Komponenten initialisieren
+        $this->flash = new FlashBag($this);
+        $this->validation = new ValidationErrorBag($this);
+        $this->form = new FormDataStorage($this);
+        $this->security = new SecurityManager($this, $this->clock);
+        $this->csrf = new CsrfProtection($this);
+    }
+
+    public function isStarted(): bool
+    {
+        return true;
+        #return $this->isStarted;
+    }
+
+    public function get(string $key, $default = null): mixed
+    {
+        return $this->data[$key] ?? $default;
+    }
+
+    public function set(string $key, $value): void
+    {
+        $this->data[$key] = $value;
+    }
+
+    public function has(string $key): bool
+    {
+        return array_key_exists($key, $this->data);
+    }
+
+    public function remove(string $key): void
+    {
+        unset($this->data[$key]);
+    }
+
+    public function all(): array
+    {
+        return $this->data;
+    }
+
+    public function clear(): void
+    {
+        $this->data = [];
+    }
+
+    public function fromArray(array $data): void
+    {
+        $this->data = $data;
+    }
+
+    public function __debugInfo(): array
+    {
+        return [$this->id->toString(), ...$this->data];
+    }
+}
diff --git a/src/Framework/Http/Session/SessionId.php b/src/Framework/Http/Session/SessionId.php
new file mode 100644
index 00000000..65576a59
--- /dev/null
+++ b/src/Framework/Http/Session/SessionId.php
@@ -0,0 +1,52 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Http\Session;
+
+use InvalidArgumentException;
+
+final readonly class SessionId
+{
+    private function __construct(private string $value)
+    {
+        $this->validate($value);
+    }
+
+    public static function fromString(string $value): self
+    {
+        return new self($value);
+    }
+
+    public function toString(): string
+    {
+        return $this->value;
+    }
+
+    public function __toString(): string
+    {
+        return $this->toString();
+    }
+
+    public function equals(SessionId $other): bool
+    {
+        return $this->value === $other->value;
+    }
+
+    private function validate(string $value): void
+    {
+        if (empty($value)) {
+            throw new InvalidArgumentException('SessionId darf nicht leer sein');
+        }
+
+        // Weitere Validierungen je nach Anforderungen
+        // z.B. Mindestlänge, erlaubte Zeichen, Format
+        if (strlen($value) < 32) {
+            throw new InvalidArgumentException('SessionId muss mindestens 32 Zeichen lang sein');
+        }
+
+        if (!ctype_alnum($value)) {
+            throw new InvalidArgumentException('SessionId darf nur alphanumerische Zeichen enthalten');
+        }
+    }
+
+}
diff --git a/src/Framework/Http/Session/SessionIdGenerator.php b/src/Framework/Http/Session/SessionIdGenerator.php
new file mode 100644
index 00000000..ee3c60b5
--- /dev/null
+++ b/src/Framework/Http/Session/SessionIdGenerator.php
@@ -0,0 +1,11 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Http\Session;
+
+interface SessionIdGenerator
+{
+    public function generate(): SessionId;
+
+    public function isValid(SessionId $id): bool;
+}
diff --git a/src/Framework/Http/Session/SessionInitializer.php b/src/Framework/Http/Session/SessionInitializer.php
new file mode 100644
index 00000000..499987f9
--- /dev/null
+++ b/src/Framework/Http/Session/SessionInitializer.php
@@ -0,0 +1,33 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Http\Session;
+
+
+use App\Framework\DateTime\Clock;
+use App\Framework\DI\Container;
+use App\Framework\DI\Initializer;
+use App\Framework\Http\ResponseManipulator;
+
+
+final readonly class SessionInitializer
+{
+    public function __construct(
+        private Container $container
+    ) {}
+
+    /**
+     * Initialisiert die Session-Komponenten im Container
+     */
+    #[Initializer]
+    public function __invoke(): SessionManager
+    {
+        $clock = $this->container->get(Clock::class);
+
+        return new SessionManager(
+            new RandomBytesSessionIdGenerator(),
+            new ResponseManipulator(),
+            $clock
+        );
+    }
+}
diff --git a/src/Framework/Http/Session/SessionInterface.php b/src/Framework/Http/Session/SessionInterface.php
new file mode 100644
index 00000000..6086fcb6
--- /dev/null
+++ b/src/Framework/Http/Session/SessionInterface.php
@@ -0,0 +1,17 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Http\Session;
+
+interface SessionInterface
+{
+    public function getId(): SessionId;
+    public function get(string $key, mixed $default = null): mixed;
+    public function set(string $key, mixed $value): void;
+    public function has(string $key): bool;
+    public function remove(string $key): void;
+    public function clear(): void;
+    public function all(): array;
+    public function isStarted(): bool;
+    public function regenerate(): void;
+}
diff --git a/src/Framework/Http/Session/SessionKey.php b/src/Framework/Http/Session/SessionKey.php
new file mode 100644
index 00000000..17cd78d8
--- /dev/null
+++ b/src/Framework/Http/Session/SessionKey.php
@@ -0,0 +1,13 @@
+<?php
+
+namespace App\Framework\Http\Session;
+
+enum SessionKey: string
+{
+    case FLASH = '__flash';
+    case FORM_DATA = '__form_data';
+    case VALIDATION_ERRORS = '__validation_errors';
+    case SECURITY = '__security';
+    case META = '__meta';
+    case CSRF = '__csrf';
+}
diff --git a/src/Framework/Http/Session/SessionManager.php b/src/Framework/Http/Session/SessionManager.php
new file mode 100644
index 00000000..4b7fbe02
--- /dev/null
+++ b/src/Framework/Http/Session/SessionManager.php
@@ -0,0 +1,156 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Http\Session;
+
+use App\Framework\DateTime\Clock;
+use App\Framework\Http\Cookies\Cookie;
+use App\Framework\Http\Cookies\Cookies;
+use App\Framework\Http\Request;
+use App\Framework\Http\Response;
+use App\Framework\Http\ResponseManipulator;
+
+final class SessionManager
+{
+    private const string SESSION_COOKIE_NAME = 'ms_context';
+
+    public function __construct(
+        private readonly SessionIdGenerator $generator,
+        private readonly ResponseManipulator $responseManipulator,
+        private readonly Clock $clock,
+        private readonly array $cookieConfig = [
+            'path' => '/',
+            'domain' => null,
+            'secure' => true,
+            'httpOnly' => true,
+            'sameSite' => 'lax',
+        ],
+        private readonly SessionStorage $storage = new RedisSessionStorage(),
+    ) {
+    }
+
+    public function getOrCreateSession(Request $request): Session
+    {
+        // Session-ID aus Cookie lesen
+        $sessionId = $this->getSessionIdFromCookies($request->cookies);
+
+        if ($sessionId !== null) {
+            // Versuchen, existierende Session zu laden
+            $data = $this->storage->read($sessionId);
+
+            $session = new Session($sessionId, $this->clock);;
+            $session->fromArray($data);
+
+            if ($session !== null) {
+
+                return $session;
+            }
+        }
+
+        // Keine gültige Session gefunden - neue erstellen
+        return $this->createNewSession();
+    }
+
+
+
+    public function createNewSession(): Session
+    {
+        $sessionId = $this->generator->generate();
+        return new Session($sessionId, $this->clock);
+    }
+
+    public function regenerateSession(Session $session): Session
+    {
+        $oldData = $session->all();
+
+        // Neue Session erstellen
+        $newSession = $this->createNewSession();
+        $newSession->fromArray($oldData);
+
+        // Session-Sicherheitsdaten aktualisieren
+        $newSession->security->markRegenerated();
+
+        // Alte Session löschen
+        $this->storage->remove($session->id);
+
+        // Neue Session speichern
+        $this->storage->write($newSession->id, $newSession->all());
+
+        return $newSession;
+    }
+
+
+    public function saveSession(Session $session, Response $response): Response
+    {
+        $this->saveSessionData($session);
+
+        // Setze das Session-Cookie
+        $cookie = new Cookie(
+            self::SESSION_COOKIE_NAME,
+            $session->id->toString(),
+            0, // 0 = Browser-Session
+            $this->cookieConfig['path'],
+            $this->cookieConfig['domain'],
+            $this->cookieConfig['secure'],
+            $this->cookieConfig['httpOnly'],
+            $this->cookieConfig['sameSite']
+        );
+
+        return $this->responseManipulator->withHeader(
+            $response,
+            'Set-Cookie',
+            $cookie->toHeaderString()
+        );
+    }
+
+    /**
+     * Speichert nur die Session-Daten ohne Cookie zu setzen
+     */
+    private function saveSessionData(Session $session): void
+    {
+        $this->storage->write($session->id, $session->all());
+    }
+
+    private function getSessionIdFromCookies(Cookies $cookies): ?SessionId
+    {
+        $sessionCookie = $cookies->get(self::SESSION_COOKIE_NAME);
+
+        if ($sessionCookie === null) {
+            return null;
+        }
+
+        return SessionId::fromString($sessionCookie->value);
+    }
+
+    public function destroySession(Session $session, Response $response): Response
+    {
+        // Session löschen
+        $this->storage->remove($session->id);
+
+        // Cookie zum Löschen setzen (abgelaufenes Datum)
+        $cookie = new Cookie(
+            self::SESSION_COOKIE_NAME,
+            '',
+            1, // In der Vergangenheit
+            $this->cookieConfig['path'],
+            $this->cookieConfig['domain'],
+            $this->cookieConfig['secure'],
+            $this->cookieConfig['httpOnly'],
+            $this->cookieConfig['sameSite']
+        );
+
+        // Cookie dem Response hinzufügen
+        return $this->responseManipulator->withHeader($response, 'Set-Cookie', $cookie->toHeaderString());
+    }
+
+    public function getCookieName(): string
+    {
+        return self::SESSION_COOKIE_NAME;
+    }
+
+    public function getCookieConfig(): array
+    {
+        return $this->cookieConfig;
+    }
+
+}
diff --git a/src/Framework/Http/Session/SessionMiddleware.php b/src/Framework/Http/Session/SessionMiddleware.php
new file mode 100644
index 00000000..937c45c9
--- /dev/null
+++ b/src/Framework/Http/Session/SessionMiddleware.php
@@ -0,0 +1,69 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Http\Session;
+
+use App\Framework\DI\Container;
+use App\Framework\Http\HttpMiddleware;
+use App\Framework\Http\MiddlewareContext;
+use App\Framework\Http\MiddlewarePriority;
+use App\Framework\Http\MiddlewarePriorityAttribute;
+use App\Framework\Http\RequestStateManager;
+use App\Framework\Http\ResponseManipulator;
+
+#[MiddlewarePriorityAttribute(MiddlewarePriority::SESSION)]
+final readonly class SessionMiddleware implements HttpMiddleware
+{
+    public function __construct(
+        private Container $container,
+        private SessionManager $sessionManager
+    ) {}
+
+    public function __invoke(MiddlewareContext $context, callable $next, RequestStateManager $stateManager): MiddlewareContext
+    {
+        $session = $this->sessionManager->getOrCreateSession($context->request);
+
+        $userAgent = $context->request->headers->get('User-Agent')[0] ?? '';
+        #$ipAddress = $context->request->headers->get('REMOTE_ADDR') ?? '';
+        $ipAddress = $context->request->server->getClientIp();
+
+        if($session->has(SessionKey::SECURITY->value)) {
+            $isValid = $session->security->validate($userAgent, $ipAddress);
+
+            if (!$isValid) {
+                // Session ist kompromittiert - neue erstellen
+                $session = $this->sessionManager->createNewSession();
+                $session->security->initialize($userAgent, $ipAddress);
+            } else {
+                // Letzte Aktivität aktualisieren
+                $session->security->updateLastActivity();
+
+                // Session-ID-Rotation bei Bedarf
+                if ($session->security->shouldRegenerateId()) {
+                    $session = $this->sessionManager->regenerateSession($session);
+                }
+            }
+        } else {
+            // Neue Session mit Sicherheitsdaten initialisieren
+            $session->security->initialize($userAgent, $ipAddress);
+        }
+
+        #$this->container->bind(Session::class, $session);
+
+        $this->container->forget(Session::class);
+        $this->container->instance(Session::class, $session);
+
+
+        $context = $next($context);
+
+
+        // Flash-Daten für den nächsten Request vorbereiten
+        $session->flash->age();
+
+        // Session speichern
+        $responseWithSession = $this->sessionManager->saveSession($session, $context->response);
+
+        return $context->withResponse($responseWithSession);
+
+    }
+}
diff --git a/src/Framework/Http/Session/SessionSecurityData.php b/src/Framework/Http/Session/SessionSecurityData.php
new file mode 100644
index 00000000..a95c35a9
--- /dev/null
+++ b/src/Framework/Http/Session/SessionSecurityData.php
@@ -0,0 +1,59 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Http\Session;
+
+use App\Framework\Http\IpAddress;
+
+final readonly class SessionSecurityData
+{
+    public function __construct(
+        public string $userAgent,
+        public IpAddress $ipAddress,
+        public int $lastActivity,
+        public int $lastRegeneration
+    ) {}
+
+    public function withLastActivity(int $lastActivity): self
+    {
+        return new self(
+            $this->userAgent,
+            $this->ipAddress,
+            $lastActivity,
+            $this->lastRegeneration
+        );
+    }
+
+    public function withLastRegeneration(int $lastRegeneration): self
+    {
+        return new self(
+            $this->userAgent,
+            $this->ipAddress,
+            $this->lastActivity,
+            $lastRegeneration
+        );
+    }
+
+    public function toArray(): array
+    {
+        return [
+            'user_agent' => $this->userAgent,
+            'ip_address' => $this->ipAddress->value,
+            'last_activity' => $this->lastActivity,
+            'last_regeneration' => $this->lastRegeneration
+        ];
+    }
+
+    public static function fromSession(Session $session): self
+    {
+        $data = $session->get(SessionKey::SECURITY->value);
+
+        return new self(
+            $data['user_agent'],
+            new IpAddress($data['ip_address']),
+            $data['last_activity'],
+            $data['last_regeneration']
+        );
+    }
+}
diff --git a/src/Framework/Http/Session/SessionStorage.php b/src/Framework/Http/Session/SessionStorage.php
new file mode 100644
index 00000000..035a7691
--- /dev/null
+++ b/src/Framework/Http/Session/SessionStorage.php
@@ -0,0 +1,12 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Http\Session;
+
+interface SessionStorage
+{
+    public function read(SessionId $id): array;
+    public function write(SessionId $id, array $data): void;
+    public function remove(SessionId $id): void;
+    public function migrate(SessionId $fromId, SessionId $toId): void;
+}
diff --git a/src/Framework/Http/Session/ValidationErrorBag.php b/src/Framework/Http/Session/ValidationErrorBag.php
new file mode 100644
index 00000000..c187e75b
--- /dev/null
+++ b/src/Framework/Http/Session/ValidationErrorBag.php
@@ -0,0 +1,208 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Http\Session;
+
+use App\Framework\Validation\ValidationResult;
+
+/**
+ * A bag for managing validation errors associated with forms.
+ *
+ * This class provides methods to store, retrieve, check, and clear validation errors
+ * for specific forms or fields within a session. Supports both single error messages
+ * and multiple error messages per field.
+ */
+final readonly class ValidationErrorBag
+{
+    public function __construct(
+        private Session $session
+    ){
+        #$this->session = $session;
+
+        // Sicherstellen, dass Validierungsbereich existiert
+        if (!$this->session->has(SessionKey::VALIDATION_ERRORS->value)) {
+            $this->session->set(SessionKey::VALIDATION_ERRORS->value, []);
+        }
+    }
+
+    /**
+     * Fügt Validierungsfehler für ein Formular hinzu
+     *
+     * @param string $formId Formular-ID
+     * @param array $errors Fehler-Array im Format ['field' => ['error1', 'error2']] oder ['field' => 'error']
+     */
+    public function add(string $formId, array $errors): void
+    {
+        $validationData = $this->session->get(SessionKey::VALIDATION_ERRORS->value, []);
+
+        // Normalisiere das Fehler-Array, um sicherzustellen, dass alle Werte Arrays sind
+        $normalizedErrors = [];
+        foreach ($errors as $field => $fieldErrors) {
+            if (is_array($fieldErrors)) {
+                $normalizedErrors[$field] = $fieldErrors;
+            } else {
+                $normalizedErrors[$field] = [$fieldErrors];
+            }
+        }
+
+        $validationData[$formId] = $normalizedErrors;
+        $this->session->set(SessionKey::VALIDATION_ERRORS->value, $validationData);
+    }
+
+    /**
+     * Fügt Validierungsfehler aus einem ValidationResult hinzu
+     */
+    public function addFromValidationResult(string $formId, ValidationResult $validationResult): void
+    {
+        $this->add($formId, $validationResult->getAll());
+    }
+
+    /**
+     * Gibt alle Fehler für ein Formular zurück
+     *
+     * @param string $formId Formular-ID
+     * @return array<string, string[]> Array von Fehlern gruppiert nach Feldern
+     */
+    public function get(string $formId): array
+    {
+        $validationData = $this->session->get(SessionKey::VALIDATION_ERRORS->value, []);
+        return $validationData[$formId] ?? [];
+    }
+
+    /**
+     * Prüft, ob Fehler für ein Formular oder Feld vorhanden sind
+     */
+    public function has(string $formId, ?string $field = null): bool
+    {
+        $validationData = $this->session->get(SessionKey::VALIDATION_ERRORS->value, []);
+
+        if (!isset($validationData[$formId])) {
+            return false;
+        }
+
+        if ($field === null) {
+            return !empty($validationData[$formId]);
+        }
+
+        return isset($validationData[$formId][$field]) && !empty($validationData[$formId][$field]);
+    }
+
+    /**
+     * Gibt alle Fehlermeldungen für ein bestimmtes Feld zurück
+     *
+     * @param string $formId Formular-ID
+     * @param string $field Feldname
+     * @return array<string> Array von Fehlermeldungen für das Feld
+     */
+    public function getFieldErrors(string $formId, string $field): array
+    {
+        $errors = $this->get($formId);
+        return $errors[$field] ?? [];
+    }
+
+    /**
+     * Gibt die erste Fehlermeldung für ein Feld zurück (Rückwärtskompatibilität)
+     *
+     * @param string $formId Formular-ID
+     * @param string $field Feldname
+     * @return string|null Erste Fehlermeldung oder null
+     */
+    public function getField(string $formId, string $field): ?string
+    {
+        $fieldErrors = $this->getFieldErrors($formId, $field);
+        return $fieldErrors[0] ?? null;
+    }
+
+    /**
+     * Gibt alle Fehlermeldungen für ein Feld als String zurück
+     *
+     * @param string $formId Formular-ID
+     * @param string $field Feldname
+     * @param string $separator Trennzeichen zwischen Fehlermeldungen
+     * @return string Alle Fehlermeldungen als String
+     */
+    public function getFieldErrorsAsString(string $formId, string $field, string $separator = ', '): string
+    {
+        $fieldErrors = $this->getFieldErrors($formId, $field);
+        return implode($separator, $fieldErrors);
+    }
+
+    /**
+     * Gibt alle Fehlermeldungen als flache Liste zurück
+     *
+     * @param string $formId Formular-ID
+     * @return array<string> Liste aller Fehlermeldungen
+     */
+    public function getAllErrorMessages(string $formId): array
+    {
+        $errors = $this->get($formId);
+        $messages = [];
+
+        foreach ($errors as $fieldErrors) {
+            foreach ($fieldErrors as $error) {
+                $messages[] = $error;
+            }
+        }
+
+        return $messages;
+    }
+
+    /**
+     * Fügt eine einzelne Fehlermeldung zu einem Feld hinzu
+     */
+    public function addFieldError(string $formId, string $field, string $error): void
+    {
+        $validationData = $this->session->get(SessionKey::VALIDATION_ERRORS->value, []);
+
+        if (!isset($validationData[$formId])) {
+            $validationData[$formId] = [];
+        }
+
+        if (!isset($validationData[$formId][$field])) {
+            $validationData[$formId][$field] = [];
+        }
+
+        $validationData[$formId][$field][] = $error;
+        $this->session->set(SessionKey::VALIDATION_ERRORS->value, $validationData);
+    }
+
+    /**
+     * Löscht alle Fehler für ein Formular
+     */
+    public function clear(string $formId): void
+    {
+        $validationData = $this->session->get(SessionKey::VALIDATION_ERRORS->value, []);
+
+        if (isset($validationData[$formId])) {
+            unset($validationData[$formId]);
+            $this->session->set(SessionKey::VALIDATION_ERRORS->value, $validationData);
+        }
+    }
+
+    /**
+     * Löscht Fehler für ein bestimmtes Feld
+     */
+    public function clearField(string $formId, string $field): void
+    {
+        $validationData = $this->session->get(SessionKey::VALIDATION_ERRORS->value, []);
+
+        if (isset($validationData[$formId][$field])) {
+            unset($validationData[$formId][$field]);
+            $this->session->set(SessionKey::VALIDATION_ERRORS->value, $validationData);
+        }
+    }
+
+    /**
+     * Löscht alle Validierungsfehler
+     */
+    public function clearAll(): void
+    {
+        $this->session->set(SessionKey::VALIDATION_ERRORS->value, []);
+    }
+
+    public function __debugInfo(): array
+    {
+        return $this->session->get(SessionKey::VALIDATION_ERRORS->value, []);
+    }
+}
diff --git a/src/Framework/Http/SseStream.php b/src/Framework/Http/SseStream.php
new file mode 100644
index 00000000..21e2e6fe
--- /dev/null
+++ b/src/Framework/Http/SseStream.php
@@ -0,0 +1,137 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Http;
+
+use App\Framework\Router\Result\SseEvent;
+
+/**
+ * Verwaltet den SSE-Stream für Server-Sent Events
+ */
+final class SseStream
+{
+    private bool $isStreaming = false;
+
+    /**
+     * Startet den SSE-Stream mit den angegebenen Headern und initialem Status
+     *
+     * @param Headers $headers Die zu sendenden HTTP-Header
+     * @param Status $status Der zu sendende HTTP-Status-Code
+     * @param array<SseEvent> $initialEvents Events, die beim Verbindungsaufbau gesendet werden
+     */
+    public function start(Headers $headers, Status $status, array $initialEvents = []): void
+    {
+        if ($this->isStreaming) {
+            return;
+        }
+
+        // HTTP-Status senden
+        http_response_code($status->value);
+
+        // Headers senden
+        foreach ($headers->toArray() as $name => $value) {
+            $value = is_string($value) ? $value : implode(', ', $value);
+            header("{$name}: {$value}");
+        }
+
+        // Output-Buffering deaktivieren
+        while (ob_get_level() > 0) {
+            ob_end_flush();
+        }
+
+        // Streamen aktivieren
+        $this->isStreaming = true;
+
+        // Initiale Events senden
+        foreach ($initialEvents as $event) {
+            $this->sendEvent($event);
+        }
+    }
+
+    /**
+     * Sendet ein einzelnes Event
+     */
+    public function sendEvent(SseEvent $event): void
+    {
+        if (!$this->isStreaming) {
+            throw new \RuntimeException('Stream muss zuerst mit start() initialisiert werden');
+        }
+
+        echo $event->format() . "\n";
+        $this->flush();
+    }
+
+    /**
+     * Sendet ein Event mit den angegebenen Parametern
+     */
+    public function send(string $data, ?string $event = null, ?string $id = null, ?int $retry = null): void
+    {
+        $this->sendEvent(new SseEvent($data, $event, $id, $retry));
+    }
+
+    /**
+     * Sendet JSON-Daten als Event
+     */
+    public function sendJson(array $data, ?string $event = null, ?string $id = null): void
+    {
+        $this->send(json_encode($data), $event, $id);
+    }
+
+    /**
+     * Sendet ein Heartbeat-Event
+     */
+    public function sendHeartbeat(?string $id = null): void
+    {
+        $this->sendJson(['timestamp' => time()], 'heartbeat', $id);
+    }
+
+    /**
+     * Sendet ein Retry-Intervall
+     */
+    public function sendRetry(int $milliseconds): void
+    {
+        $this->send('', null, null, $milliseconds);
+    }
+
+    /**
+     * Schließt die Verbindung mit einem abschließenden Event
+     */
+    public function close(?string $message = null): void
+    {
+        if (!$this->isStreaming) {
+            return;
+        }
+
+        $data = $message ?? 'Connection closed';
+        $this->send($data, 'close');
+
+        $this->isStreaming = false;
+    }
+
+    /**
+     * Leert den Ausgabepuffer und sendet Daten zum Client
+     */
+    private function flush(): void
+    {
+        if (ob_get_level() > 0) {
+            ob_flush();
+        }
+        flush();
+    }
+
+    /**
+     * Prüft, ob die Client-Verbindung noch aktiv ist
+     */
+    public function isConnectionActive(): bool
+    {
+        return !connection_aborted();
+    }
+
+    /**
+     * Gibt zurück, ob der Stream aktiv ist
+     */
+    public function isActive(): bool
+    {
+        return $this->isStreaming;
+    }
+}
diff --git a/src/Framework/Http/Status.php b/src/Framework/Http/Status.php
index 1f16a301..8ced1ca6 100644
--- a/src/Framework/Http/Status.php
+++ b/src/Framework/Http/Status.php
@@ -4,10 +4,196 @@ declare(strict_types=1);
 
 namespace App\Framework\Http;
 
+/**
+ * Enum representing HTTP status codes and their respective numeric values.
+ *
+ * This enumeration is used to represent standard HTTP status codes as defined
+ * by the Internet Assigned Numbers Authority (IANA). It includes informational,
+ * success, redirection, client error, and server error status codes.
+ */
 enum Status: int
 {
+    case CONTINUE = 100;
+    case SWITCHING_PROTOCOLS = 101;
+    case PROCESSING = 102;
+    case EARLY_HINTS = 103;
+
     case OK = 200;
-    case NOT_FOUND = 404;
+    case CREATED = 201;
+    case ACCEPTED = 202;
+    case NON_AUTHORITATIVE_INFORMATION = 203;
+    case NO_CONTENT = 204;
+    case RESET_CONTENT = 205;
+    case PARTIAL_CONTENT = 206;
+    case MULTI_STATUS = 207;
+    case ALREADY_REPORTED = 208;
+    case IM_USED = 226;
+
+    case MULTIPLE_CHOICES = 300;
+    case MOVED_PERMANENTLY = 301;
     case FOUND = 302;
+    case SEE_OTHER = 303;
+    case NOT_MODIFIED = 304;
+    case USE_PROXY = 305;
+    case TEMPORARY_REDIRECT = 307;
+    case PERMANENT_REDIRECT = 308;
+
+    case BAD_REQUEST = 400;
+    case UNAUTHORIZED = 401;
+    case PAYMENT_REQUIRED = 402;
+    case FORBIDDEN = 403;
+    case NOT_FOUND = 404;
+    case METHOD_NOT_ALLOWED = 405;
+    case NOT_ACCEPTABLE = 406;
+    case PROXY_AUTHENTICATION_REQUIRED = 407;
+    case REQUEST_TIMEOUT = 408;
+    case CONFLICT = 409;
+    case GONE = 410;
+    case LENGTH_REQUIRED = 411;
+    case PRECONDITION_FAILED = 412;
+    case PAYLOAD_TOO_LARGE = 413;
+    case URI_TOO_LONG = 414;
+    case UNSUPPORTED_MEDIA_TYPE = 415;
+    case RANGE_NOT_SATISFIABLE = 416;
+    case EXPECTATION_FAILED = 417;
+    case IM_A_TEAPOT = 418;
+    case MISDIRECTED_REQUEST = 421;
+    case UNPROCESSABLE_ENTITY = 422;
+    case LOCKED = 423;
+    case FAILED_DEPENDENCY = 424;
+    case TOO_EARLY = 425;
+    case UPGRADE_REQUIRED = 426;
+    case PRECONDITION_REQUIRED = 428;
+    case TOO_MANY_REQUESTS = 429;
+    case REQUEST_HEADER_FIELDS_TOO_LARGE = 431;
+    case UNAVAILABLE_FOR_LEGAL_REASONS = 451;
+
     case INTERNAL_SERVER_ERROR = 500;
+    case NOT_IMPLEMENTED = 501;
+    case BAD_GATEWAY = 502;
+    case SERVICE_UNAVAILABLE = 503;
+    case GATEWAY_TIMEOUT = 504;
+    case HTTP_VERSION_NOT_SUPPORTED = 505;
+    case VARIANT_ALSO_NEGOTIATES = 506;
+    case INSUFFICIENT_STORAGE = 507;
+    case LOOP_DETECTED = 508;
+    case NOT_EXTENDED = 510;
+    case NETWORK_AUTHENTICATION_REQUIRED = 511;
+
+
+    /**
+     * Gibt eine menschenlesbare Beschreibung des Status-Codes zurück
+     */
+    public function getDescription(): string
+    {
+        return match ($this) {
+            // 1xx
+            self::CONTINUE => 'Continue',
+            self::SWITCHING_PROTOCOLS => 'Switching Protocols',
+            self::PROCESSING => 'Processing',
+            self::EARLY_HINTS => 'Early Hints',
+            // 2xx
+            self::OK => 'OK',
+            self::CREATED => 'Created',
+            self::ACCEPTED => 'Accepted',
+            self::NON_AUTHORITATIVE_INFORMATION => 'Non-Authoritative Information',
+            self::NO_CONTENT => 'No Content',
+            self::RESET_CONTENT => 'Reset Content',
+            self::PARTIAL_CONTENT => 'Partial Content',
+            self::MULTI_STATUS => 'Multi-Status',
+            self::ALREADY_REPORTED => 'Already Reported',
+            self::IM_USED => 'IM Used',
+            // 3xx
+            self::MULTIPLE_CHOICES => 'Multiple Choices',
+            self::MOVED_PERMANENTLY => 'Moved Permanently',
+            self::FOUND => 'Found',
+            self::SEE_OTHER => 'See Other',
+            self::NOT_MODIFIED => 'Not Modified',
+            self::USE_PROXY => 'Use Proxy',
+            self::TEMPORARY_REDIRECT => 'Temporary Redirect',
+            self::PERMANENT_REDIRECT => 'Permanent Redirect',
+            // 4xx
+            self::BAD_REQUEST => 'Bad Request',
+            self::UNAUTHORIZED => 'Unauthorized',
+            self::PAYMENT_REQUIRED => 'Payment Required',
+            self::FORBIDDEN => 'Forbidden',
+            self::NOT_FOUND => 'Not Found',
+            self::METHOD_NOT_ALLOWED => 'Method Not Allowed',
+            self::NOT_ACCEPTABLE => 'Not Acceptable',
+            self::PROXY_AUTHENTICATION_REQUIRED => 'Proxy Authentication Required',
+            self::REQUEST_TIMEOUT => 'Request Timeout',
+            self::CONFLICT => 'Conflict',
+            self::GONE => 'Gone',
+            self::LENGTH_REQUIRED => 'Length Required',
+            self::PRECONDITION_FAILED => 'Precondition Failed',
+            self::PAYLOAD_TOO_LARGE => 'Payload Too Large',
+            self::URI_TOO_LONG => 'URI Too Long',
+            self::UNSUPPORTED_MEDIA_TYPE => 'Unsupported Media Type',
+            self::RANGE_NOT_SATISFIABLE => 'Range Not Satisfiable',
+            self::EXPECTATION_FAILED => 'Expectation Failed',
+            self::IM_A_TEAPOT => "I'm a teapot",
+            self::MISDIRECTED_REQUEST => 'Misdirected Request',
+            self::UNPROCESSABLE_ENTITY => 'Unprocessable Entity',
+            self::LOCKED => 'Locked',
+            self::FAILED_DEPENDENCY => 'Failed Dependency',
+            self::TOO_EARLY => 'Too Early',
+            self::UPGRADE_REQUIRED => 'Upgrade Required',
+            self::PRECONDITION_REQUIRED => 'Precondition Required',
+            self::TOO_MANY_REQUESTS => 'Too Many Requests',
+            self::REQUEST_HEADER_FIELDS_TOO_LARGE => 'Request Header Fields Too Large',
+            self::UNAVAILABLE_FOR_LEGAL_REASONS => 'Unavailable For Legal Reasons',
+            // 5xx
+            self::INTERNAL_SERVER_ERROR => 'Internal Server Error',
+            self::NOT_IMPLEMENTED => 'Not Implemented',
+            self::BAD_GATEWAY => 'Bad Gateway',
+            self::SERVICE_UNAVAILABLE => 'Service Unavailable',
+            self::GATEWAY_TIMEOUT => 'Gateway Timeout',
+            self::HTTP_VERSION_NOT_SUPPORTED => 'HTTP Version Not Supported',
+            self::VARIANT_ALSO_NEGOTIATES => 'Variant Also Negotiates',
+            self::INSUFFICIENT_STORAGE => 'Insufficient Storage',
+            self::LOOP_DETECTED => 'Loop Detected',
+            self::NOT_EXTENDED => 'Not Extended',
+            self::NETWORK_AUTHENTICATION_REQUIRED => 'Network Authentication Required',
+        };
+    }
+
+    /**
+     * Gibt zurück, ob der Status-Code ein Erfolg (2xx) ist
+     */
+    public function isSuccess(): bool
+    {
+        return $this->value >= 200 && $this->value < 300;
+    }
+
+    /**
+     * Gibt zurück, ob der Status-Code eine Weiterleitung (3xx) ist
+     */
+    public function isRedirection(): bool
+    {
+        return $this->value >= 300 && $this->value < 400;
+    }
+
+    /**
+     * Gibt zurück, ob der Status-Code ein Client-Fehler (4xx) ist
+     */
+    public function isClientError(): bool
+    {
+        return $this->value >= 400 && $this->value < 500;
+    }
+
+    /**
+     * Gibt zurück, ob der Status-Code ein Server-Fehler (5xx) ist
+     */
+    public function isServerError(): bool
+    {
+        return $this->value >= 500 && $this->value < 600;
+    }
+
+    /**
+     * Gibt zurück, ob der Status-Code ein Fehler (4xx oder 5xx) ist
+     */
+    public function isError(): bool
+    {
+        return $this->isClientError() || $this->isServerError();
+    }
 }
diff --git a/src/Framework/Http/Streaming/AdaptivePlaylist.php b/src/Framework/Http/Streaming/AdaptivePlaylist.php
new file mode 100644
index 00000000..9ed27893
--- /dev/null
+++ b/src/Framework/Http/Streaming/AdaptivePlaylist.php
@@ -0,0 +1,140 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Http\Streaming;
+
+final class AdaptivePlaylist
+{
+    private array $representations = [];
+    private array $segments = [];
+
+    public function __construct(
+        private readonly string $videoId,
+        private readonly PlaylistType $type = PlaylistType::MASTER)
+    {}
+
+    public function addRepresentation(
+        string $id,
+        int $bandwidth,
+        string $resolution = '',
+        string $codecs = '',
+        string $mimeType = 'video/mp4'
+    ): self {
+        $this->representations[] = new StreamRepresentation(
+            $id, $bandwidth, $resolution, $codecs, $mimeType
+        );
+        return $this;
+    }
+
+    public function addSegment(string $uri, float $duration, ?int $sequence = null): self
+    {
+        $this->segments[] = [
+            'uri' => $uri,
+            'duration' => $duration,
+            'sequence' => $sequence ?? count($this->segments)
+        ];
+        return $this;
+    }
+
+    public function generate(StreamingFormat $format): string
+    {
+        return match ($format) {
+            StreamingFormat::HLS => $this->generateHls(),
+            StreamingFormat::DASH => $this->generateDash()
+        };
+    }
+
+    private function generateHls(): string
+    {
+        if ($this->type === PlaylistType::MASTER) {
+            return $this->generateHlsMaster();
+        }
+        return $this->generateHlsMedia();
+    }
+
+    private function generateDash(): string
+    {
+        return $this->generateDashManifest();
+    }
+
+    private function generateHlsMaster(): string
+    {
+        $playlist = "#EXTM3U\n#EXT-X-VERSION:3\n";
+
+        foreach ($this->representations as $rep) {
+            $playlist .= "#EXT-X-STREAM-INF:BANDWIDTH={$rep->bandwidth}";
+            if ($rep->resolution) {
+                $playlist .= ",RESOLUTION={$rep->resolution}";
+            }
+            if ($rep->codecs) {
+                $playlist .= ",CODECS=\"{$rep->codecs}\"";
+            }
+            $playlist .= "\n{$rep->id}.m3u8\n";
+        }
+
+        return $playlist;
+    }
+
+    private function generateHlsMedia(): string
+    {
+        $playlist = "#EXTM3U\n#EXT-X-VERSION:3\n";
+        $playlist .= "#EXT-X-TARGETDURATION:10\n";
+        $playlist .= "#EXT-X-MEDIA-SEQUENCE:0\n";
+
+        foreach ($this->segments as $segment) {
+            $playlist .= "#EXTINF:{$segment['duration']},\n";
+            $playlist .= "{$segment['uri']}\n";
+        }
+
+        $playlist .= "#EXT-X-ENDLIST\n";
+        return $playlist;
+    }
+
+    private function generateDashManifest(): string
+    {
+        $xml = '<?xml version="1.0" encoding="utf-8"?>' . "\n";
+        $xml .= '<MPD xmlns="urn:mpeg:dash:schema:mpd:2011" ';
+        $xml .= 'type="static" mediaPresentationDuration="PT0H10M0S" ';
+        $xml .= 'minBufferTime="PT2S" profiles="urn:mpeg:dash:profile:isoff-main:2011">' . "\n";
+
+        $xml .= '<Period>' . "\n";
+        $xml .= '<AdaptationSet mimeType="video/mp4" codecs="avc1.64001f">' . "\n";
+
+        foreach ($this->representations as $rep) {
+            $xml .= '<Representation id="' . $rep->id . '" ';
+            $xml .= 'bandwidth="' . $rep->bandwidth . '" ';
+            if ($rep->resolution) {
+                [$width, $height] = explode('x', $rep->resolution);
+                $xml .= 'width="' . $width . '" height="' . $height . '" ';
+            }
+            $xml .= 'codecs="' . $rep->codecs . '">' . "\n";
+            $xml .= '<BaseURL>' . $rep->id . '/</BaseURL>' . "\n";
+            $xml .= '<SegmentList>' . "\n";
+
+            // Segments hinzufügen
+            foreach ($this->segments as $segment) {
+                $xml .= '<SegmentURL media="' . $segment['uri'] . '"/>' . "\n";
+            }
+
+            $xml .= '</SegmentList>' . "\n";
+            $xml .= '</Representation>' . "\n";
+        }
+
+        $xml .= '</AdaptationSet>' . "\n";
+        $xml .= '</Period>' . "\n";
+        $xml .= '</MPD>';
+
+        return $xml;
+    }
+
+    public function getRepresentations(): array
+    {
+        return $this->representations;
+    }
+
+    public function getSegments(): array
+    {
+        return $this->segments;
+    }
+}
diff --git a/src/Framework/Http/Streaming/AdaptiveStreamingController.php b/src/Framework/Http/Streaming/AdaptiveStreamingController.php
new file mode 100644
index 00000000..25c45370
--- /dev/null
+++ b/src/Framework/Http/Streaming/AdaptiveStreamingController.php
@@ -0,0 +1,137 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Http\Streaming;
+
+use App\Framework\Http\Responses\AdaptiveStreamResponse;
+use App\Framework\Http\Responses\MediaType;
+use App\Framework\Http\Responses\StreamResponse;
+
+class AdaptiveStreamingController
+{
+    public function manifest(string $videoId): AdaptiveStreamResponse
+    {
+        // Format basierend auf User-Agent oder Accept-Header erkennen
+        $format = $this->detectPreferredFormat();
+
+        return $this->createManifest($videoId, $format);
+    }
+
+    public function hlsManifest(string $videoId): AdaptiveStreamResponse
+    {
+        return $this->createManifest($videoId, StreamingFormat::HLS);
+    }
+
+    public function dashManifest(string $videoId): AdaptiveStreamResponse
+    {
+        return $this->createManifest($videoId, StreamingFormat::DASH);
+    }
+
+    public function hlsMediaPlaylist(string $videoId, string $quality): AdaptiveStreamResponse
+    {
+        $playlist = new AdaptivePlaylist($videoId, PlaylistType::MEDIA);
+
+        // Video-Segmente für diese Qualität laden
+        $segments = $this->getVideoSegments($videoId, $quality);
+
+        foreach ($segments as $segment) {
+            $playlist->addSegment(
+                uri: "segment_{$segment['sequence']}.ts",
+                duration: $segment['duration']
+            );
+        }
+
+        return new AdaptiveStreamResponse(
+            playlist: $playlist,
+            format: StreamingFormat::HLS
+        );
+    }
+
+    public function segment(string $videoId, string $quality, string $segment): StreamResponse
+    {
+        $segmentPath = $this->getSegmentPath($videoId, $quality, $segment);
+
+        if (!file_exists($segmentPath)) {
+            throw new \RuntimeException('Segment not found');
+        }
+
+        return new StreamResponse(
+            filePath: $segmentPath,
+            fileSize: filesize($segmentPath),
+            mimeType: $this->getSegmentMimeType($segment),
+            mediaType: MediaType::VIDEO
+        );
+    }
+
+    private function createManifest(string $videoId, StreamingFormat $format): AdaptiveStreamResponse
+    {
+        $playlist = new AdaptivePlaylist($videoId, PlaylistType::MASTER);
+
+        // Standard-Qualitätsstufen
+        $playlist
+            ->addRepresentation('720p', 2500000, '1280x720', 'avc1.64001f,mp4a.40.2')
+            ->addRepresentation('480p', 1500000, '854x480', 'avc1.64001e,mp4a.40.2')
+            ->addRepresentation('360p', 800000, '640x360', 'avc1.64001e,mp4a.40.2');
+
+        return new AdaptiveStreamResponse(
+            playlist: $playlist,
+            format: $format
+        );
+    }
+
+    private function detectPreferredFormat(): StreamingFormat
+    {
+        $userAgent = $_SERVER['HTTP_USER_AGENT'] ?? '';
+
+        // iOS/Safari bevorzugt HLS
+        if (str_contains($userAgent, 'Safari') && str_contains($userAgent, 'Mobile')) {
+            return StreamingFormat::HLS;
+        }
+
+        // Android/Chrome bevorzugt DASH
+        if (str_contains($userAgent, 'Chrome') || str_contains($userAgent, 'Android')) {
+            return StreamingFormat::DASH;
+        }
+
+        // Accept-Header prüfen
+        $accept = $_SERVER['HTTP_ACCEPT'] ?? '';
+        if (str_contains($accept, 'application/dash+xml')) {
+            return StreamingFormat::DASH;
+        }
+        if (str_contains($accept, 'application/vnd.apple.mpegurl')) {
+            return StreamingFormat::HLS;
+        }
+
+        // Default: HLS (breitere Unterstützung)
+        return StreamingFormat::HLS;
+    }
+
+    private function getVideoSegments(string $videoId, string $quality): array
+    {
+        // In einer echten Anwendung würden diese aus der Datenbank kommen
+        return [
+            ['sequence' => 0, 'duration' => 10.0],
+            ['sequence' => 1, 'duration' => 10.0],
+            ['sequence' => 2, 'duration' => 10.0],
+            ['sequence' => 3, 'duration' => 8.5], // Letztes Segment kann kürzer sein
+        ];
+    }
+
+    private function getSegmentPath(string $videoId, string $quality, string $segment): string
+    {
+        return "/var/videos/segments/{$videoId}/{$quality}/{$segment}";
+    }
+
+    private function getSegmentMimeType(string $segment): string
+    {
+        if (str_ends_with($segment, '.ts')) {
+            return 'video/mp2t'; // MPEG-TS für HLS
+        }
+        if (str_ends_with($segment, '.mp4')) {
+            return 'video/mp4'; // MP4 für DASH
+        }
+
+        return 'application/octet-stream';
+    }
+}
diff --git a/src/Framework/Http/Streaming/MimeTypeDetector.php b/src/Framework/Http/Streaming/MimeTypeDetector.php
new file mode 100644
index 00000000..30abdfd9
--- /dev/null
+++ b/src/Framework/Http/Streaming/MimeTypeDetector.php
@@ -0,0 +1,37 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Http\Streaming;
+
+final class MimeTypeDetector
+{
+    private const MIME_TYPES = [
+        // Video
+        'mp4' => 'video/mp4',
+        'webm' => 'video/webm',
+        'ogg' => 'video/ogg',
+        'avi' => 'video/x-msvideo',
+        'mov' => 'video/quicktime',
+        'mkv' => 'video/x-matroska',
+
+        // Audio
+        'mp3' => 'audio/mpeg',
+        'wav' => 'audio/wav',
+        'flac' => 'audio/flac',
+        'ogg' => 'audio/ogg', // Kann Audio oder Video sein
+        'aac' => 'audio/aac',
+        'm4a' => 'audio/mp4',
+    ];
+
+    public static function detect(string $filePath): string
+    {
+        $extension = strtolower(pathinfo($filePath, PATHINFO_EXTENSION));
+        return self::MIME_TYPES[$extension] ?? 'application/octet-stream';
+    }
+
+    public static function isStreamable(string $mimeType): bool
+    {
+        return str_starts_with($mimeType, 'video/') ||
+            str_starts_with($mimeType, 'audio/');
+    }
+}
diff --git a/src/Framework/Http/Streaming/PlaylistType.php b/src/Framework/Http/Streaming/PlaylistType.php
new file mode 100644
index 00000000..4784751c
--- /dev/null
+++ b/src/Framework/Http/Streaming/PlaylistType.php
@@ -0,0 +1,11 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Http\Streaming;
+
+enum PlaylistType: string
+{
+    case MASTER = 'master';
+    case MEDIA = 'media';
+}
diff --git a/src/Framework/Http/Streaming/RangeParser.php b/src/Framework/Http/Streaming/RangeParser.php
new file mode 100644
index 00000000..cafec120
--- /dev/null
+++ b/src/Framework/Http/Streaming/RangeParser.php
@@ -0,0 +1,48 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Http\Streaming;
+
+use App\Framework\Http\Range;
+
+final readonly class RangeParser
+{
+    public static function parseRange(string $rangeHeader, int $fileSize): ?Range
+    {
+        // Format: "bytes=start-end"
+        if (!preg_match('/bytes=(\d*)-(\d*)/', $rangeHeader, $matches)) {
+            return null;
+        }
+
+        $start = $matches[1] !== '' ? (int)$matches[1] : 0;
+        $end = $matches[2] !== '' ? (int)$matches[2] : $fileSize - 1;
+
+        // Validierung
+        if ($start >= $fileSize || $end >= $fileSize || $start > $end) {
+            return null;
+        }
+
+        return new Range($start, $end, $fileSize);
+    }
+
+
+    /**
+     * @return Range[]
+     */
+    public static function parseMultipleRanges(string $rangeHeader, int $fileSize): array
+    {
+        // Für mehrere Ranges: "bytes=0-499,1000-1499"
+        $ranges = [];
+
+        if (preg_match_all('/(\d*)-(\d*)/', $rangeHeader, $matches, PREG_SET_ORDER)) {
+            foreach ($matches as $match) {
+                $range = self::parseRange("bytes={$match[0]}", $fileSize);
+                if ($range !== null) {
+                    $ranges[] = $range;
+                }
+            }
+        }
+
+        return $ranges;
+    }
+}
diff --git a/src/Framework/Http/Streaming/StreamRepresentation.php b/src/Framework/Http/Streaming/StreamRepresentation.php
new file mode 100644
index 00000000..0838608d
--- /dev/null
+++ b/src/Framework/Http/Streaming/StreamRepresentation.php
@@ -0,0 +1,16 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Http\Streaming;
+
+final readonly class StreamRepresentation
+{
+    public function __construct(
+        public string $id,
+        public int $bandwidth,
+        public string $resolution = '',
+        public string $codecs = '',
+        public string $mimeType = 'video/mp4'
+    ) {}
+}
diff --git a/src/Framework/Http/Streaming/StreamingFormat.php b/src/Framework/Http/Streaming/StreamingFormat.php
new file mode 100644
index 00000000..6354585a
--- /dev/null
+++ b/src/Framework/Http/Streaming/StreamingFormat.php
@@ -0,0 +1,27 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Http\Streaming;
+
+enum StreamingFormat: string
+{
+    case HLS = 'hls';
+    case DASH = 'dash';
+
+    public function getContentType(): string
+    {
+        return match ($this) {
+            self::HLS => 'application/vnd.apple.mpegurl',
+            self::DASH => 'application/dash+xml'
+        };
+    }
+
+    public function getFileExtension(): string
+    {
+        return match ($this) {
+            self::HLS => 'm3u8',
+            self::DASH => 'mpd'
+        };
+    }
+}
diff --git a/src/Framework/Http/UploadError.php b/src/Framework/Http/UploadError.php
new file mode 100644
index 00000000..7e9d0566
--- /dev/null
+++ b/src/Framework/Http/UploadError.php
@@ -0,0 +1,49 @@
+<?php
+
+namespace App\Framework\Http;
+
+enum UploadError: int
+{
+    case OK = 0;
+    case INI_SIZE = 1;
+    case FORM_SIZE = 2;
+    case PARTIAL = 3;
+    case NO_FILE = 4;
+    case NO_TMP_DIR = 6;
+    case CANT_WRITE = 7;
+    case EXTENSION = 8;
+
+    public static function fromUploadError(int $error): self
+    {
+        return match ($error) {
+            UPLOAD_ERR_OK => self::OK,
+            UPLOAD_ERR_INI_SIZE => self::INI_SIZE,
+            UPLOAD_ERR_FORM_SIZE => self::FORM_SIZE,
+            UPLOAD_ERR_PARTIAL => self::PARTIAL,
+            UPLOAD_ERR_NO_FILE => self::NO_FILE,
+            UPLOAD_ERR_NO_TMP_DIR => self::NO_TMP_DIR,
+            UPLOAD_ERR_CANT_WRITE => self::CANT_WRITE,
+            UPLOAD_ERR_EXTENSION => self::EXTENSION,
+            default => self::NO_FILE,
+        };
+    }
+
+    public function getMessage(): string
+    {
+        return match ($this) {
+            self::OK => 'Upload erfolgreich',
+            self::INI_SIZE => 'Datei überschreitet upload_max_filesize',
+            self::FORM_SIZE => 'Datei überschreitet MAX_FILE_SIZE des HTML-Formulars',
+            self::PARTIAL => 'Datei wurde nur teilweise hochgeladen',
+            self::NO_FILE => 'Keine Datei hochgeladen',
+            self::NO_TMP_DIR => 'Temporärer Ordner fehlt',
+            self::CANT_WRITE => 'Fehler beim Schreiben auf Festplatte',
+            self::EXTENSION => 'Upload durch PHP-Erweiterung gestoppt',
+        };
+    }
+
+    public function isError(): bool
+    {
+        return $this !== self::OK;
+    }
+}
diff --git a/src/Framework/Http/UploadedFile.php b/src/Framework/Http/UploadedFile.php
new file mode 100644
index 00000000..f0452089
--- /dev/null
+++ b/src/Framework/Http/UploadedFile.php
@@ -0,0 +1,38 @@
+<?php
+
+namespace App\Framework\Http;
+
+final readonly class UploadedFile
+{
+    public function __construct(
+        public string $name,
+        public string $type,
+        public int $size,
+        public string $tmpName,
+        public UploadError $error,
+    ) {
+        if($this->isValid() === false) {
+            throw new \InvalidArgumentException("Invalid uploaded file: {$this->name}");
+        }
+    }
+
+    public function getExtension(): ?string
+    {
+        return pathinfo($this->name, PATHINFO_EXTENSION) ?: null;
+    }
+
+    public function getFileName(): string
+    {
+        return pathinfo($this->name, PATHINFO_FILENAME);
+    }
+
+    private function isValid(): bool
+    {
+        return $this->error === UploadError::OK && is_uploaded_file($this->tmpName);
+    }
+
+    public function getMimeType(): string
+    {
+        return mime_content_type($this->tmpName);
+    }
+}
diff --git a/src/Framework/Http/UploadedFiles.php b/src/Framework/Http/UploadedFiles.php
new file mode 100644
index 00000000..165d90b4
--- /dev/null
+++ b/src/Framework/Http/UploadedFiles.php
@@ -0,0 +1,56 @@
+<?php
+
+namespace App\Framework\Http;
+
+final readonly class UploadedFiles
+{
+    /** @var array<string, UploadedFile|UploadedFile[]> */
+    private array $files;
+
+    public function __construct(array $filesArray)
+    {
+        $this->files = array_map(function ($fileSpec) {
+            return is_array($fileSpec['name'])
+                ? $this->createMultipleFiles($fileSpec)
+                : $this->createSingleFile($fileSpec);
+        }, $filesArray);
+    }
+
+    private function createSingleFile(array $fileSpec): UploadedFile
+    {
+        return new UploadedFile(
+            $fileSpec['name'] ?? '',
+            $fileSpec['type'] ?? '',
+            $fileSpec['size'] ?? 0,
+            $fileSpec['tmp_name'] ?? '',
+            UploadError::fromUploadError($fileSpec['error'] ?? UPLOAD_ERR_NO_FILE),
+        );
+    }
+
+    private function createMultipleFiles(array $fileSpec): array
+    {
+        return array_map(
+            fn($index) => new UploadedFile(
+                $fileSpec['name'][$index] ?? '',
+                $fileSpec['type'][$index] ?? '',
+                $fileSpec['size'][$index] ?? 0,
+                $fileSpec['tmp_name'][$index] ?? '',
+                UploadError::fromUploadError($fileSpec['error'][$index] ?? UPLOAD_ERR_NO_FILE),
+            ),
+            array_keys($fileSpec['name'])
+        );
+    }
+
+    public function get(string $key): ?UploadedFile
+    {
+        return $this->files[$key] ?? null;
+    }
+
+    /**
+     * @return array<string, UploadedFile|UploadedFile[]>
+     */
+    public function all(): array
+    {
+        return $this->files;
+    }
+}
diff --git a/src/Framework/Http/Uri.php b/src/Framework/Http/Uri.php
new file mode 100644
index 00000000..abab6fd9
--- /dev/null
+++ b/src/Framework/Http/Uri.php
@@ -0,0 +1,28 @@
+<?php
+
+namespace App\Framework\Http;
+
+/**
+ * Value Object für URLs/URIs
+ */
+final readonly class Uri
+{
+    public function __construct(
+        public string $value
+    ) {}
+
+    public function getPath(): string
+    {
+        return parse_url($this->value, PHP_URL_PATH) ?? '/';
+    }
+
+    public function getQuery(): string
+    {
+        return parse_url($this->value, PHP_URL_QUERY) ?? '';
+    }
+
+    public function __toString(): string
+    {
+        return $this->value;
+    }
+}
diff --git a/src/Framework/Http/WebSocketConnection.php b/src/Framework/Http/WebSocketConnection.php
new file mode 100644
index 00000000..3ee1416d
--- /dev/null
+++ b/src/Framework/Http/WebSocketConnection.php
@@ -0,0 +1,166 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Http;
+
+/**
+ * Repräsentiert eine aktive WebSocket-Verbindung
+ */
+final class WebSocketConnection
+{
+    private bool $isConnected = true;
+    private array $attributes = [];
+
+    public function __construct(
+        private readonly string $id,
+        private $socket
+    ) {}
+
+    /**
+     * Sendet eine Text-Nachricht
+     */
+    public function send(string $message): bool
+    {
+        if (!$this->isConnected) {
+            return false;
+        }
+
+        try {
+            $frame = $this->createFrame($message, 0x1); // Text frame
+            return fwrite($this->socket, $frame) !== false;
+        } catch (\Throwable $e) {
+            $this->disconnect();
+            return false;
+        }
+    }
+
+    /**
+     * Sendet JSON-Daten
+     */
+    public function sendJson(array $data): bool
+    {
+        return $this->send(json_encode($data));
+    }
+
+    /**
+     * Sendet Binärdaten
+     */
+    public function sendBinary(string $data): bool
+    {
+        if (!$this->isConnected) {
+            return false;
+        }
+
+        try {
+            $frame = $this->createFrame($data, 0x2); // Binary frame
+            return fwrite($this->socket, $frame) !== false;
+        } catch (\Throwable $e) {
+            $this->disconnect();
+            return false;
+        }
+    }
+
+    /**
+     * Sendet einen Ping
+     */
+    public function ping(string $data = ''): bool
+    {
+        if (!$this->isConnected) {
+            return false;
+        }
+
+        try {
+            $frame = $this->createFrame($data, 0x9); // Ping frame
+            return fwrite($this->socket, $frame) !== false;
+        } catch (\Throwable $e) {
+            $this->disconnect();
+            return false;
+        }
+    }
+
+    /**
+     * Schließt die Verbindung
+     */
+    public function close(int $code = 1000, string $reason = ''): void
+    {
+        if (!$this->isConnected) {
+            return;
+        }
+
+        try {
+            $payload = pack('n', $code) . $reason;
+            $frame = $this->createFrame($payload, 0x8); // Close frame
+            fwrite($this->socket, $frame);
+        } catch (\Throwable $e) {
+            // Fehler beim Senden des Close-Frames ignorieren
+        }
+
+        $this->disconnect();
+    }
+
+    /**
+     * Trennt die Verbindung
+     */
+    public function disconnect(): void
+    {
+        $this->isConnected = false;
+        if (is_resource($this->socket)) {
+            fclose($this->socket);
+        }
+    }
+
+    /**
+     * Erstellt einen WebSocket-Frame
+     */
+    private function createFrame(string $payload, int $opcode): string
+    {
+        $payloadLength = strlen($payload);
+        $frame = '';
+
+        // Erste Byte: FIN (1) + RSV (000) + Opcode (4 bits)
+        $frame .= chr(0x80 | $opcode);
+
+        // Payload-Länge
+        if ($payloadLength < 126) {
+            $frame .= chr($payloadLength);
+        } elseif ($payloadLength < 65536) {
+            $frame .= chr(126) . pack('n', $payloadLength);
+        } else {
+            $frame .= chr(127) . pack('J', $payloadLength);
+        }
+
+        return $frame . $payload;
+    }
+
+    /**
+     * Setzt ein Attribut für diese Verbindung
+     */
+    public function setAttribute(string $key, mixed $value): void
+    {
+        $this->attributes[$key] = $value;
+    }
+
+    /**
+     * Gibt ein Attribut zurück
+     */
+    public function getAttribute(string $key, mixed $default = null): mixed
+    {
+        return $this->attributes[$key] ?? $default;
+    }
+
+    /**
+     * Prüft, ob die Verbindung aktiv ist
+     */
+    public function isConnected(): bool
+    {
+        return $this->isConnected;
+    }
+
+    /**
+     * Gibt die Verbindungs-ID zurück
+     */
+    public function getId(): string
+    {
+        return $this->id;
+    }
+}
diff --git a/src/Framework/Http/WebSocketServer.php b/src/Framework/Http/WebSocketServer.php
new file mode 100644
index 00000000..64ccee96
--- /dev/null
+++ b/src/Framework/Http/WebSocketServer.php
@@ -0,0 +1,227 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Http;
+
+use App\Framework\Http\Responses\WebSocketResponse;
+use App\Framework\Router\Result\WebSocketResult;
+
+/**
+ * WebSocket-Server für die Verarbeitung von WebSocket-Verbindungen
+ */
+final class WebSocketServer
+{
+    private array $connections = [];
+
+    public function handleUpgrade(WebSocketResponse $response): void
+    {
+        $webSocketResult = $response->getWebSocketResult();
+
+        // Socket-Stream abrufen (vereinfacht für Demonstration)
+        $socket = $this->getCurrentSocket();
+
+        if (!$socket) {
+            return;
+        }
+
+        // Verbindung erstellen
+        $connectionId = uniqid('ws_', true);
+        $connection = new WebSocketConnection($connectionId, $socket);
+        $this->connections[$connectionId] = $connection;
+
+        // onConnect-Handler aufrufen
+        if ($webSocketResult->getOnConnect()) {
+            try {
+                call_user_func($webSocketResult->getOnConnect(), $connection);
+            } catch (\Throwable $e) {
+                $this->handleError($connection, $e, $webSocketResult);
+                return;
+            }
+        }
+
+        // Message-Loop starten
+        $this->messageLoop($connection, $webSocketResult);
+    }
+
+    /**
+     * Hauptschleife für die Nachrichtenverarbeitung
+     */
+    private function messageLoop(WebSocketConnection $connection, WebSocketResult $result): void
+    {
+        $socket = $this->getSocketFromConnection($connection);
+        $lastPing = time();
+        $pingInterval = $result->getPingInterval();
+
+        while ($connection->isConnected()) {
+            // Socket auf Lesbarkeit prüfen
+            $read = [$socket];
+            $write = [];
+            $except = [];
+
+            $ready = stream_select($read, $write, $except, 1); // 1 Sekunde Timeout
+
+            if ($ready === false) {
+                break; // Fehler
+            }
+
+            if ($ready > 0) {
+                // Nachricht lesen
+                $message = $this->readMessage($socket, $result->getMaxMessageSize());
+
+                if ($message === false) {
+                    break; // Verbindung geschlossen oder Fehler
+                }
+
+                if ($message !== null) {
+                    // onMessage-Handler aufrufen
+                    if ($result->getOnMessage()) {
+                        try {
+                            call_user_func($result->getOnMessage(), $connection, $message);
+                        } catch (\Throwable $e) {
+                            $this->handleError($connection, $e, $result);
+                            break;
+                        }
+                    }
+                }
+            }
+
+            // Ping senden, falls nötig
+            if (time() - $lastPing >= $pingInterval) {
+                $connection->ping();
+                $lastPing = time();
+            }
+        }
+
+        // Verbindung schließen
+        $this->closeConnection($connection, $result);
+    }
+
+    /**
+     * Liest eine WebSocket-Nachricht
+     */
+    private function readMessage($socket, int $maxSize): string|false|null
+    {
+        // Vereinfachte WebSocket-Frame-Dekodierung
+        $header = fread($socket, 2);
+        if (strlen($header) !== 2) {
+            return false;
+        }
+
+        $firstByte = ord($header[0]);
+        $secondByte = ord($header[1]);
+
+        $opcode = $firstByte & 0x0F;
+        $masked = ($secondByte & 0x80) === 0x80;
+        $payloadLength = $secondByte & 0x7F;
+
+        // Erweiterte Payload-Länge lesen
+        if ($payloadLength === 126) {
+            $extLength = fread($socket, 2);
+            if (strlen($extLength) !== 2) {
+                return false;
+            }
+            $payloadLength = unpack('n', $extLength)[1];
+        } elseif ($payloadLength === 127) {
+            $extLength = fread($socket, 8);
+            if (strlen($extLength) !== 8) {
+                return false;
+            }
+            $payloadLength = unpack('J', $extLength)[1];
+        }
+
+        // Größencheck
+        if ($payloadLength > $maxSize) {
+            return false;
+        }
+
+        // Maske lesen (falls vorhanden)
+        $maskingKey = '';
+        if ($masked) {
+            $maskingKey = fread($socket, 4);
+            if (strlen($maskingKey) !== 4) {
+                return false;
+            }
+        }
+
+        // Payload lesen
+        $payload = '';
+        if ($payloadLength > 0) {
+            $payload = fread($socket, $payloadLength);
+            if (strlen($payload) !== $payloadLength) {
+                return false;
+            }
+
+            // Demaskierung
+            if ($masked) {
+                for ($i = 0; $i < $payloadLength; $i++) {
+                    $payload[$i] = chr(ord($payload[$i]) ^ ord($maskingKey[$i % 4]));
+                }
+            }
+        }
+
+        // Frame-Typ verarbeiten
+        switch ($opcode) {
+            case 0x1: // Text
+                return $payload;
+            case 0x2: // Binary
+                return $payload;
+            case 0x8: // Close
+                return false;
+            case 0x9: // Ping
+                // Pong senden
+                $this->sendPong($socket, $payload);
+                return null;
+            case 0xA: // Pong
+                return null;
+            default:
+                return null;
+        }
+    }
+
+    private function sendPong($socket, string $data): void
+    {
+        $frame = chr(0x8A) . chr(strlen($data)) . $data;
+        fwrite($socket, $frame);
+    }
+
+    private function handleError(WebSocketConnection $connection, \Throwable $error, WebSocketResult $result): void
+    {
+        if ($result->getOnError()) {
+            try {
+                call_user_func($result->getOnError(), $connection, $error);
+            } catch (\Throwable $e) {
+                // Fehler im Error-Handler ignorieren
+            }
+        }
+    }
+
+    private function closeConnection(WebSocketConnection $connection, WebSocketResult $result): void
+    {
+        if ($result->getOnClose()) {
+            try {
+                call_user_func($result->getOnClose(), $connection, 1000, 'Normal closure');
+            } catch (\Throwable $e) {
+                // Fehler im Close-Handler ignorieren
+            }
+        }
+
+        $connection->disconnect();
+        unset($this->connections[$connection->getId()]);
+    }
+
+    /**
+     * Hilfsmethoden (vereinfacht für Demo)
+     */
+    private function getCurrentSocket()
+    {
+        // In einer echten Implementierung würdest du hier den aktuellen Socket abrufen
+        // Für PHP-FPM/Apache ist das komplizierter, da du keinen direkten Socket-Zugriff hast
+        return null;
+    }
+
+    private function getSocketFromConnection(WebSocketConnection $connection)
+    {
+        // Socket aus der Verbindung extrahieren
+        return null;
+    }
+}
diff --git a/src/Framework/HttpClient/AuthConfig.php b/src/Framework/HttpClient/AuthConfig.php
new file mode 100644
index 00000000..dc38969c
--- /dev/null
+++ b/src/Framework/HttpClient/AuthConfig.php
@@ -0,0 +1,52 @@
+<?php
+
+namespace App\Framework\HttpClient;
+
+
+final readonly class AuthConfig
+{
+    private function __construct(
+        public AuthType $type,
+        public array $credentials
+    ) {}
+
+    public static function basic(string $username, string $password): self
+    {
+        return new self(
+            AuthType::Basic,
+            ['username' => $username, 'password' => $password]
+        );
+    }
+
+    public static function bearer(string $token): self
+    {
+        return new self(
+            AuthType::Bearer,
+            ['token' => $token]
+        );
+    }
+
+    public static function oauth2(string $token): self
+    {
+        return new self(
+            AuthType::OAuth2,
+            ['token' => $token]
+        );
+    }
+
+    public static function digest(string $username, string $password): self
+    {
+        return new self(
+            AuthType::Digest,
+            ['username' => $username, 'password' => $password]
+        );
+    }
+
+    public static function custom(array $headers): self
+    {
+        return new self(
+            AuthType::Custom,
+            ['headers' => $headers]
+        );
+    }
+}
diff --git a/src/Framework/HttpClient/AuthResult.php b/src/Framework/HttpClient/AuthResult.php
new file mode 100644
index 00000000..9e428110
--- /dev/null
+++ b/src/Framework/HttpClient/AuthResult.php
@@ -0,0 +1,13 @@
+<?php
+
+namespace App\Framework\HttpClient;
+
+use App\Framework\Http\Headers;
+
+final readonly class AuthResult
+{
+    public function __construct(
+        public Headers $headers,
+        public array $curlOptions = [],
+    ){}
+}
diff --git a/src/Framework/HttpClient/AuthType.php b/src/Framework/HttpClient/AuthType.php
new file mode 100644
index 00000000..f11d8f4b
--- /dev/null
+++ b/src/Framework/HttpClient/AuthType.php
@@ -0,0 +1,13 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\HttpClient;
+
+enum AuthType
+{
+    case Basic;
+    case Bearer;
+    case OAuth2;
+    case Digest;
+    case Custom;
+}
diff --git a/src/Framework/HttpClient/AuthenticationHandler.php b/src/Framework/HttpClient/AuthenticationHandler.php
new file mode 100644
index 00000000..34c5089a
--- /dev/null
+++ b/src/Framework/HttpClient/AuthenticationHandler.php
@@ -0,0 +1,65 @@
+<?php
+
+namespace App\Framework\HttpClient;
+
+use App\Framework\Http\Headers;
+
+final readonly class AuthenticationHandler
+{
+    public function configure(AuthConfig $auth, Headers $headers): AuthResult
+    {
+        return match ($auth->type) {
+            AuthType::Basic => $this->setupBasicAuth($auth->credentials, $headers),
+            AuthType::Bearer => $this->setupBearerAuth($auth->credentials, $headers),
+            AuthType::OAuth2 => $this->setupOAuth2Auth($auth->credentials, $headers),
+            AuthType::Digest => $this->setupDigestAuth($auth->credentials, $headers),
+            AuthType::Custom => $this->setupCustomAuth($auth->credentials, $headers),
+        };
+    }
+
+    private function setupBasicAuth(array $credentials, Headers $headers): AuthResult
+    {
+        $curlOptions = [];
+        if (isset($credentials['username'], $credentials['password'])) {
+            $curlOptions[CURLOPT_USERPWD] = "{$credentials['username']}:{$credentials['password']}";
+            $curlOptions[CURLOPT_HTTPAUTH] = CURLAUTH_BASIC;
+        }
+        return new AuthResult($headers, $curlOptions);
+    }
+
+    private function setupBearerAuth(array $credentials, Headers $headers): AuthResult
+    {
+        if (isset($credentials['token'])) {
+            $headers = $headers->with('Authorization', "Bearer {$credentials['token']}");
+        }
+        return new AuthResult($headers);
+    }
+
+    private function setupOAuth2Auth(array $credentials, Headers $headers): AuthResult
+    {
+        if (isset($credentials['token'])) {
+            $headers = $headers->with('Authorization', "Bearer {$credentials['token']}");
+        }
+        return new AuthResult($headers);
+    }
+
+    private function setupDigestAuth(array $credentials, Headers $headers): AuthResult
+    {
+        $curlOptions = [];
+        if (isset($credentials['username'], $credentials['password'])) {
+            $curlOptions[CURLOPT_USERPWD] = "{$credentials['username']}:{$credentials['password']}";
+            $curlOptions[CURLOPT_HTTPAUTH] = CURLAUTH_DIGEST;
+        }
+        return new AuthResult($headers, $curlOptions);
+    }
+
+    private function setupCustomAuth(array $credentials, Headers $headers): AuthResult
+    {
+        if (isset($credentials['headers']) && is_array($credentials['headers'])) {
+            foreach ($credentials['headers'] as $name => $value) {
+                $headers = $headers->with($name, $value);
+            }
+        }
+        return new AuthResult($headers);
+    }
+}
diff --git a/src/Framework/HttpClient/ClientOptions.php b/src/Framework/HttpClient/ClientOptions.php
index 193a8323..abc30d6c 100644
--- a/src/Framework/HttpClient/ClientOptions.php
+++ b/src/Framework/HttpClient/ClientOptions.php
@@ -5,11 +5,97 @@ namespace App\Framework\HttpClient;
 final readonly class ClientOptions
 {
     public function __construct(
-        public float  $timeout = 10.0,
-        public bool   $followRedirects = true,
-        public ?array $auth = null,
-        public bool   $verifySsl = true
-        // ... beliebig erweiterbar
+        public float $timeout = 10.0,
+        public float $connectTimeout = 3.0,
+        public bool $followRedirects = true,
+        public int $maxRedirects = 5,
+        public bool $verifySsl = true,
+        public array $query = [],
+        public ?string $userAgent = null,
+        public ?string $proxy = null,
+        public ?AuthConfig $auth = null,
+        public array $curlOptions = [], // Für zusätzliche cURL-Optionen
+        public bool $throwOnError = true, // Soll bei 4xx/5xx Exceptions geworfen werden?
+        public array $allowedStatusCodes = [], // Erlaubte Status-Codes (wenn nicht leer)
     ) {}
 
+    /**
+     * Erstellt neue Optionen mit geänderten Werten
+     */
+    public function with(array $options): self
+    {
+        return new self(
+            timeout: $options['timeout'] ?? $this->timeout,
+            connectTimeout: $options['connectTimeout'] ?? $this->connectTimeout,
+            followRedirects: $options['followRedirects'] ?? $this->followRedirects,
+            maxRedirects: $options['maxRedirects'] ?? $this->maxRedirects,
+            verifySsl: $options['verifySsl'] ?? $this->verifySsl,
+            query: $options['query'] ?? $this->query,
+            userAgent: $options['userAgent'] ?? $this->userAgent,
+            proxy: $options['proxy'] ?? $this->proxy,
+            auth: $options['auth'] ?? $this->auth,
+            curlOptions: $options['curlOptions'] ?? $this->curlOptions,
+            throwOnError: $options['throwOnError'] ?? $this->throwOnError,
+            allowedStatusCodes: $options['allowedStatusCodes'] ?? $this->allowedStatusCodes,
+        );
+    }
+
+    /**
+     * Factory-Methoden für häufige Konfigurationen
+     */
+    public static function withTimeout(float $timeout): self
+    {
+        return new self(timeout: $timeout);
+    }
+
+    public static function withAuth(AuthConfig $auth): self
+    {
+        return new self(auth: $auth);
+    }
+
+    public static function withProxy(string $proxy): self
+    {
+        return new self(proxy: $proxy);
+    }
+
+    public static function insecure(): self
+    {
+        return new self(verifySsl: false);
+    }
+
+    public static function withoutRedirects(): self
+    {
+        return new self(followRedirects: false);
+    }
+
+    public static function withQuery(array $query): self
+    {
+        return new self(query: $query);
+    }
+
+    public static function withUserAgent(string $userAgent): self
+    {
+        return new self(userAgent: $userAgent);
+    }
+
+    /**
+     * Kombiniert diese Optionen mit anderen
+     */
+    public function merge(ClientOptions $other): self
+    {
+        return new self(
+            timeout: $other->timeout !== 10.0 ? $other->timeout : $this->timeout,
+            connectTimeout: $other->connectTimeout !== 3.0 ? $other->connectTimeout : $this->connectTimeout,
+            followRedirects: $other->followRedirects !== true ? $other->followRedirects : $this->followRedirects,
+            maxRedirects: $other->maxRedirects !== 5 ? $other->maxRedirects : $this->maxRedirects,
+            verifySsl: $other->verifySsl !== true ? $other->verifySsl : $this->verifySsl,
+            query: array_merge($this->query, $other->query),
+            userAgent: $other->userAgent ?? $this->userAgent,
+            proxy: $other->proxy ?? $this->proxy,
+            auth: $other->auth ?? $this->auth,
+            curlOptions: array_merge($this->curlOptions, $other->curlOptions),
+            throwOnError: $other->throwOnError !== true ? $other->throwOnError : $this->throwOnError,
+            allowedStatusCodes: !empty($other->allowedStatusCodes) ? $other->allowedStatusCodes : $this->allowedStatusCodes,
+        );
+    }
 }
diff --git a/src/Framework/HttpClient/ClientRequest.php b/src/Framework/HttpClient/ClientRequest.php
index 1773498d..352bb708 100644
--- a/src/Framework/HttpClient/ClientRequest.php
+++ b/src/Framework/HttpClient/ClientRequest.php
@@ -3,16 +3,97 @@
 namespace App\Framework\HttpClient;
 
 use App\Framework\Http\Headers;
-use App\Framework\Http\HttpMethod;
+use App\Framework\Http\Method;
 
 final readonly class ClientRequest
 {
     public function __construct(
-        public HttpMethod       $method,
-        public string           $url,
-        public Headers          $headers = new Headers(),
-        public string           $body = '',
-        public ClientOptions    $options = new ClientOptions() // Z.B.. Timeout, Query-Parameter, Auth, etc.
+        public Method        $method,
+        public string        $url,
+        public Headers       $headers = new Headers(),
+        public string|array  $body = '',
+        public ClientOptions $options = new ClientOptions()
     ) {}
 
+    /**
+     * Erstellt eine neue Anfrage mit geänderten Parametern
+     */
+    public function with(array $parameters = []): self
+    {
+        return new self(
+            method: $parameters['method'] ?? $this->method,
+            url: $parameters['url'] ?? $this->url,
+            headers: $parameters['headers'] ?? $this->headers,
+            body: $parameters['body'] ?? $this->body,
+            options: $parameters['options'] ?? $this->options
+        );
+    }
+
+    /**
+     * Erstellt eine Anfrage mit JSON-Body
+     */
+    public static function json(
+        Method         $method,
+        string         $url,
+        array          $data,
+        ?ClientOptions $options = null
+    ): self {
+        $headers = new Headers()->with('Content-Type', 'application/json');
+
+        return new self(
+            method: $method,
+            url: $url,
+            headers: $headers,
+            body: json_encode($data, JSON_THROW_ON_ERROR),
+            options: $options ?? new ClientOptions()
+        );
+    }
+
+    /**
+     * Erstellt eine Anfrage mit Form-Daten
+     */
+    public static function form(
+        Method         $method,
+        string         $url,
+        array          $data,
+        ?ClientOptions $options = null
+    ): self {
+        $headers = new Headers()->with('Content-Type', 'application/x-www-form-urlencoded');
+
+        return new self(
+            method: $method,
+            url: $url,
+            headers: $headers,
+            body: http_build_query($data),
+            options: $options ?? new ClientOptions()
+        );
+    }
+
+    /**
+     * Erstellt eine Anfrage mit Multipart-Form-Daten (für Datei-Uploads)
+     */
+    public static function multipart(
+        Method         $method,
+        string         $url,
+        array          $data,
+        array          $files = [],
+        ?ClientOptions $options = null
+    ): self {
+        // Bei Multipart setzt cURL den Content-Type automatisch mit Boundary
+        $headers = new Headers();
+
+        // Transformiere Dateien in das cURL-Format für CURLOPT_POSTFIELDS
+        $formData = $data;
+        foreach ($files as $name => $filePath) {
+            $formData[$name] = curl_file_create($filePath);
+        }
+
+        return new self(
+            method: $method,
+            url: $url,
+            headers: $headers,
+            body: $formData, // cURL verarbeitet das automatisch als Multipart
+            options: $options ?? new ClientOptions()
+        );
+    }
 }
diff --git a/src/Framework/HttpClient/ClientResponse.php b/src/Framework/HttpClient/ClientResponse.php
index 589be91d..b43c58be 100644
--- a/src/Framework/HttpClient/ClientResponse.php
+++ b/src/Framework/HttpClient/ClientResponse.php
@@ -2,7 +2,9 @@
 
 namespace App\Framework\HttpClient;
 
+use App\Framework\Http\HeaderKey;
 use App\Framework\Http\Headers;
+use App\Framework\Http\MimeType;
 use App\Framework\Http\Status;
 
 final readonly class ClientResponse
@@ -13,4 +15,26 @@ final readonly class ClientResponse
         public string  $body
     ) {}
 
+    public function isSuccessful(): bool
+    {
+        return $this->status->isSuccess();
+    }
+
+    public function isJson(): bool
+    {
+        return str_contains($this->getContentType(), "json");
+
+        return $this->headers->has(HeaderKey::CONTENT_TYPE)
+            && in_array(MimeType::APPLICATION_JSON->value, $this->headers->get(HeaderKey::CONTENT_TYPE));
+    }
+
+    public function json(): array
+    {
+        return json_decode($this->body, true);
+    }
+
+    public function getContentType():string
+    {
+        return $this->headers->get(HeaderKey::CONTENT_TYPE)[0];
+    }
 }
diff --git a/src/Framework/HttpClient/CurlHttpClient.php b/src/Framework/HttpClient/CurlHttpClient.php
index 097a1fb4..864b13ee 100644
--- a/src/Framework/HttpClient/CurlHttpClient.php
+++ b/src/Framework/HttpClient/CurlHttpClient.php
@@ -2,27 +2,129 @@
 
 namespace App\Framework\HttpClient;
 
+use App\Framework\Http\HeaderManipulator;
 use App\Framework\Http\Headers;
 use App\Framework\Http\Status;
+use App\Framework\HttpClient\Exception\CurlExecutionFailed;
+use App\Framework\HttpClient\Exception\CurlNotInitialized;
+use CurlHandle;
 
 final readonly class CurlHttpClient implements HttpClient
 {
+    public function __construct(
+        private CurlResponseParser    $responseParser = new CurlResponseParser,
+        private AuthenticationHandler $authenticationHandler = new AuthenticationHandler,
+        private CurlRequestBuilder    $requestBuilder = new CurlRequestBuilder,
+    ){}
 
+    public function initializeCurl(): \CurlHandle
+    {
+        $curlHandle = curl_init();
+
+        if($curlHandle === false) {
+            throw new CurlNotInitialized();
+        }
+
+        return $curlHandle;
+    }
+
+    public function configureCurlRequest(CurlHandle $ch, ClientRequest $request): void
+    {
+        $options = $this->requestBuilder->buildOptions($request);
+
+        if($request->options->auth !== []) {
+
+            $authResult = $this->authenticationHandler->configure($request->options->auth, $request->headers);
+
+            if($authResult->headers !== $request->headers) {
+                $updatedRequest = $request->with(['headers' => $authResult->headers]);
+                $options = $this->requestBuilder->buildOptions($updatedRequest);
+            } else {
+                $options = $this->requestBuilder->buildOptions($request);
+            }
+
+            if(!empty($authResult->curlOptions)) {
+                $options = array_replace($options, $authResult->curlOptions);
+            }
+        }
+
+        curl_setopt_array($ch, $options);
+    }
+
+    public function executeCurlRequest(CurlHandle $ch): string
+    {
+        $rawResponse = curl_exec($ch);
+
+        if($rawResponse === false) {
+            throw new CurlExecutionFailed(curl_error($ch), curl_errno($ch));
+        }
+
+        return $rawResponse;
+    }
+
+    /**
+     * @throws CurlExecutionFailed
+     */
     public function send(ClientRequest $request): ClientResponse
     {
-        $ch = curl_init();
+        $ch = $this->initializeCurl();
+
+        try {
+            $this->configureCurlRequest($ch, $request);
+            $rawResponse = $this->executeCurlRequest($ch);
+
+            return $this->responseParser->parse($rawResponse, $ch);
+        } finally {
+            curl_close($ch);
+        }
+
+
+
+
+/*
+        // URL mit Query-Parametern verarbeiten
+        $url = $request->url;
+        if (!empty($request->options->query)) {
+            $separator = str_contains($url, '?') ? '&' : '?';
+            $url .= $separator . http_build_query($request->options->query);
+        }
 
         $options = [
-            CURLOPT_URL => $request->url,
+            CURLOPT_URL => $url,
             CURLOPT_CUSTOMREQUEST => $request->method->value,
             CURLOPT_RETURNTRANSFER => true,
             CURLOPT_HEADER => true,
+            CURLOPT_TIMEOUT => $request->options->timeout,
+            CURLOPT_CONNECTTIMEOUT => $request->options->connectTimeout,
+            CURLOPT_FOLLOWLOCATION => $request->options->followRedirects,
+            CURLOPT_MAXREDIRS => $request->options->maxRedirects,
+            CURLOPT_SSL_VERIFYPEER => $request->options->verifySsl,
+            CURLOPT_SSL_VERIFYHOST => $request->options->verifySsl ? 2 : 0,
         ];
+
+        // User-Agent setzen wenn vorhanden
+        if ($request->options->userAgent !== null) {
+            $options[CURLOPT_USERAGENT] = $request->options->userAgent;
+        }
+
+        // Proxy setzen wenn vorhanden
+        if ($request->options->proxy !== null) {
+            $options[CURLOPT_PROXY] = $request->options->proxy;
+        }
+
+        // Authentifizierung einrichten
+        if ($request->options->auth !== null) {
+            $this->setupAuthentication($ch, $request->options->auth, $request->headers);
+        }
+
+        // Request-Body verarbeiten
         if ($request->body !== '') {
             $options[CURLOPT_POSTFIELDS] = $request->body;
         }
+
+        // Headers formatieren und setzen
         if (count($request->headers->all()) > 0) {
-            $options[CURLOPT_HTTPHEADER] = $request->headers->all();
+            $options[CURLOPT_HTTPHEADER] = HeaderManipulator::formatForCurl($request->headers);
         }
 
         curl_setopt_array($ch, $options);
@@ -30,7 +132,7 @@ final readonly class CurlHttpClient implements HttpClient
         $raw = curl_exec($ch);
 
         if ($raw === false) {
-            throw new HttpException(curl_error($ch), curl_errno($ch));
+            throw new CurlExecutionFailed(curl_error($ch), curl_errno($ch));
         }
 
         $headerSize = curl_getinfo($ch, CURLINFO_HEADER_SIZE);
@@ -38,12 +140,12 @@ final readonly class CurlHttpClient implements HttpClient
         $body = substr($raw, $headerSize);
         $status = curl_getinfo($ch, CURLINFO_HTTP_CODE);
 
-        curl_close($ch);
-
-        #$headers = Headers::fromString($headersRaw);
-        $headers = new Headers();
-
-        return new ClientResponse(Status::from($status), $headers, $body);
+        $headers = HeaderManipulator::fromString($headersRaw);
 
+        return new ClientResponse(
+            status: Status::from($status),
+            headers: $headers,
+            body: $body
+        );*/
     }
 }
diff --git a/src/Framework/HttpClient/CurlRequestBuilder.php b/src/Framework/HttpClient/CurlRequestBuilder.php
new file mode 100644
index 00000000..3c71d465
--- /dev/null
+++ b/src/Framework/HttpClient/CurlRequestBuilder.php
@@ -0,0 +1,48 @@
+<?php
+
+namespace App\Framework\HttpClient;
+
+use App\Framework\Http\HeaderManipulator;
+
+final readonly class CurlRequestBuilder
+{
+    public function buildOptions(ClientRequest $request): array
+    {
+        $url = $request->url;
+        if (!empty($request->options->query)) {
+            $separator = str_contains($url, '?') ? '&' : '?';
+            $url .= $separator . http_build_query($request->options->query);
+        }
+
+        $options = [
+            CURLOPT_URL => $url,
+            CURLOPT_CUSTOMREQUEST => $request->method->value,
+            CURLOPT_RETURNTRANSFER => true,
+            CURLOPT_HEADER => true,
+            CURLOPT_TIMEOUT => $request->options->timeout,
+            CURLOPT_CONNECTTIMEOUT => $request->options->connectTimeout,
+            CURLOPT_FOLLOWLOCATION => $request->options->followRedirects,
+            CURLOPT_MAXREDIRS => $request->options->maxRedirects,
+            CURLOPT_SSL_VERIFYPEER => $request->options->verifySsl,
+            CURLOPT_SSL_VERIFYHOST => $request->options->verifySsl ? 2 : 0,
+        ];
+
+        if ($request->options->userAgent !== null) {
+            $options[CURLOPT_USERAGENT] = $request->options->userAgent;
+        }
+
+        if ($request->options->proxy !== null) {
+            $options[CURLOPT_PROXY] = $request->options->proxy;
+        }
+
+        if ($request->body !== '') {
+            $options[CURLOPT_POSTFIELDS] = $request->body;
+        }
+
+        if (count($request->headers->all()) > 0) {
+            $options[CURLOPT_HTTPHEADER] = HeaderManipulator::formatForCurl($request->headers);
+        }
+
+        return $options;
+    }
+}
diff --git a/src/Framework/HttpClient/CurlResponseParser.php b/src/Framework/HttpClient/CurlResponseParser.php
new file mode 100644
index 00000000..4e5a3155
--- /dev/null
+++ b/src/Framework/HttpClient/CurlResponseParser.php
@@ -0,0 +1,38 @@
+<?php
+
+namespace App\Framework\HttpClient;
+
+use App\Framework\Http\Headers;
+use App\Framework\Http\Status;
+use CurlHandle;
+
+final readonly class CurlResponseParser
+{
+    public function parse(string $rawResponse, CurlHandle $curlHandle): ClientResponse
+    {
+        $headerSize = curl_getinfo($curlHandle, CURLINFO_HEADER_SIZE);
+        $headersRaw = substr($rawResponse, 0, $headerSize);
+        $body = substr($rawResponse, $headerSize);
+        $statusCode = curl_getinfo($curlHandle, CURLINFO_HTTP_CODE);
+
+        $headers = $this->parseHeaders($headersRaw);
+        $status = Status::from($statusCode);
+
+        return new ClientResponse($status, $headers, $body);
+    }
+
+    private function parseHeaders(string $headersRaw): Headers
+    {
+        $headers = new Headers();
+        $lines = explode("\r\n", trim($headersRaw));
+
+        foreach ($lines as $line) {
+            if (str_contains($line, ':')) {
+                [$name, $value] = explode(':', $line, 2);
+                $headers = $headers->with(trim($name), trim($value));
+            }
+        }
+
+        return $headers;
+    }
+}
diff --git a/src/Framework/HttpClient/DefaultHttpClient.php b/src/Framework/HttpClient/DefaultHttpClient.php
new file mode 100644
index 00000000..8f0b395d
--- /dev/null
+++ b/src/Framework/HttpClient/DefaultHttpClient.php
@@ -0,0 +1,23 @@
+<?php
+
+namespace App\Framework\HttpClient;
+
+final readonly class DefaultHttpClient implements HttpClient
+{
+    public function __construct(
+        private HttpClient        $client = new HttpClientWithMiddleware(new CurlHttpClient()),
+        private RequestValidator  $requestValidator = new RequestValidator(),
+        private ResponseValidator $responseValidator = new ResponseValidator(),
+    ){}
+
+    public function send(ClientRequest $request): ClientResponse
+    {
+        $this->requestValidator->validate($request);
+
+        $response = $this->client->send($request);
+
+        $this->responseValidator->validate($response, $request->options);
+
+        return $response;
+    }
+}
diff --git a/src/Framework/HttpClient/Exception/ClientErrorException.php b/src/Framework/HttpClient/Exception/ClientErrorException.php
new file mode 100644
index 00000000..d4aa69da
--- /dev/null
+++ b/src/Framework/HttpClient/Exception/ClientErrorException.php
@@ -0,0 +1,16 @@
+<?php
+
+namespace App\Framework\HttpClient\Exception;
+
+class ClientErrorException extends HttpClientException
+{
+
+    /**
+     * @param string $message
+     * @param ClientResponse $response
+     */
+    public function __construct(string $message, \App\Framework\HttpClient\ClientResponse $response)
+    {
+        parent::__construct($message);
+    }
+}
diff --git a/src/Framework/HttpClient/Exception/CurlExecutionFailed.php b/src/Framework/HttpClient/Exception/CurlExecutionFailed.php
new file mode 100644
index 00000000..9b081727
--- /dev/null
+++ b/src/Framework/HttpClient/Exception/CurlExecutionFailed.php
@@ -0,0 +1,13 @@
+<?php
+
+namespace App\Framework\HttpClient\Exception;
+
+use App\Framework\Exception\FrameworkException;
+
+class CurlExecutionFailed extends FrameworkException
+{
+    public function __construct( string $message, int $code)
+    {
+        parent::__construct("Curl konnte nicht ausgeführt werden. ($message) [$code]");
+    }
+}
diff --git a/src/Framework/HttpClient/Exception/CurlNotInitialized.php b/src/Framework/HttpClient/Exception/CurlNotInitialized.php
new file mode 100644
index 00000000..902c1ef0
--- /dev/null
+++ b/src/Framework/HttpClient/Exception/CurlNotInitialized.php
@@ -0,0 +1,13 @@
+<?php
+
+namespace App\Framework\HttpClient\Exception;
+
+use App\Framework\Exception\FrameworkException;
+
+class CurlNotInitialized extends FrameworkException
+{
+    public function __construct()
+    {
+        parent::__construct("Curl konnte nicht initialisiert werden.");
+    }
+}
diff --git a/src/Framework/HttpClient/Exception/HttpClientException.php b/src/Framework/HttpClient/Exception/HttpClientException.php
new file mode 100644
index 00000000..fb82623c
--- /dev/null
+++ b/src/Framework/HttpClient/Exception/HttpClientException.php
@@ -0,0 +1,10 @@
+<?php
+
+namespace App\Framework\HttpClient\Exception;
+
+use App\Framework\Exception\FrameworkException;
+
+class HttpClientException extends FrameworkException
+{
+
+}
diff --git a/src/Framework/HttpClient/Exception/RequestValidationException.php b/src/Framework/HttpClient/Exception/RequestValidationException.php
new file mode 100644
index 00000000..7d731718
--- /dev/null
+++ b/src/Framework/HttpClient/Exception/RequestValidationException.php
@@ -0,0 +1,8 @@
+<?php
+
+namespace App\Framework\HttpClient\Exception;
+
+class RequestValidationException extends HttpClientException
+{
+
+}
diff --git a/src/Framework/HttpClient/Exception/ResponseValidationException.php b/src/Framework/HttpClient/Exception/ResponseValidationException.php
new file mode 100644
index 00000000..820232ad
--- /dev/null
+++ b/src/Framework/HttpClient/Exception/ResponseValidationException.php
@@ -0,0 +1,8 @@
+<?php
+
+namespace App\Framework\HttpClient\Exception;
+
+class ResponseValidationException extends HttpClientException
+{
+
+}
diff --git a/src/Framework/HttpClient/Exception/ServerErrorException.php b/src/Framework/HttpClient/Exception/ServerErrorException.php
new file mode 100644
index 00000000..c4e67df1
--- /dev/null
+++ b/src/Framework/HttpClient/Exception/ServerErrorException.php
@@ -0,0 +1,16 @@
+<?php
+
+namespace App\Framework\HttpClient\Exception;
+
+class ServerErrorException extends HttpClientException
+{
+
+    /**
+     * @param string $message
+     * @param ClientResponse $response
+     */
+    public function __construct(string $message, \App\Framework\HttpClient\ClientResponse $response)
+    {
+        parent::__construct($message);
+    }
+}
diff --git a/src/Framework/HttpClient/HttpClientInitializer.php b/src/Framework/HttpClient/HttpClientInitializer.php
new file mode 100644
index 00000000..3a3ef3b9
--- /dev/null
+++ b/src/Framework/HttpClient/HttpClientInitializer.php
@@ -0,0 +1,14 @@
+<?php
+
+namespace App\Framework\HttpClient;
+
+use App\Framework\DI\Initializer;
+
+final readonly class HttpClientInitializer
+{
+    #[Initializer]
+    public function __invoke(): HttpClient
+    {
+        return new DefaultHttpClient();
+    }
+}
diff --git a/src/Framework/HttpClient/HttpClientMiddleware.php b/src/Framework/HttpClient/HttpClientMiddleware.php
new file mode 100644
index 00000000..6eb99149
--- /dev/null
+++ b/src/Framework/HttpClient/HttpClientMiddleware.php
@@ -0,0 +1,8 @@
+<?php
+
+namespace App\Framework\HttpClient;
+
+interface HttpClientMiddleware
+{
+    public function __invoke(ClientRequest $request, callable $next): ClientResponse;
+}
diff --git a/src/Framework/HttpClient/HttpClientWithMiddleware.php b/src/Framework/HttpClient/HttpClientWithMiddleware.php
new file mode 100644
index 00000000..51f730bb
--- /dev/null
+++ b/src/Framework/HttpClient/HttpClientWithMiddleware.php
@@ -0,0 +1,43 @@
+<?php
+
+namespace App\Framework\HttpClient;
+
+final class HttpClientWithMiddleware implements HttpClient
+{
+    /** @var HttpClientMiddleware[] */
+    private array $middlewares = [];
+
+    public function __construct(
+        private readonly HttpClient $client
+    ) {}
+
+    /**
+     * Fügt Middleware hinzu
+     */
+    public function addMiddleware(HttpClientMiddleware $middleware): self
+    {
+        $this->middlewares[] = $middleware;
+        return $this;
+    }
+
+    /**
+     * Führt Request mit Middleware-Chain aus
+     */
+    public function send(ClientRequest $request): ClientResponse
+    {
+        $handler = $this->buildHandler();
+        return $handler($request);
+    }
+
+    private function buildHandler(): callable
+    {
+        $handler = fn(ClientRequest $request) => $this->client->send($request);
+
+        // Middleware in umgekehrter Reihenfolge anwenden
+        foreach (array_reverse($this->middlewares) as $middleware) {
+            $handler = fn(ClientRequest $request) => $middleware($request, $handler);
+        }
+
+        return $handler;
+    }
+}
diff --git a/src/Framework/HttpClient/Middleware/CachingMiddleware.php b/src/Framework/HttpClient/Middleware/CachingMiddleware.php
new file mode 100644
index 00000000..4c6fd2f2
--- /dev/null
+++ b/src/Framework/HttpClient/Middleware/CachingMiddleware.php
@@ -0,0 +1,58 @@
+<?php
+
+namespace App\Framework\HttpClient\Middleware;
+
+use App\Framework\Cache\Cache;
+use App\Framework\HttpClient\ClientRequest;
+use App\Framework\HttpClient\ClientResponse;
+use App\Framework\HttpClient\HttpClientMiddleware;
+
+final readonly class CachingMiddleware implements HttpClientMiddleware
+{
+    public function __construct(
+        private Cache $cache,
+        private int $defaultTtl = 300
+    ){}
+
+    public function __invoke(ClientRequest $request, callable $next): ClientResponse
+    {
+        // Nur GET-Requests cachen
+        if ($request->method->value !== 'GET') {
+            return $next($request);
+        }
+
+        $cacheKey = $this->generateCacheKey($request);
+
+        // Prüfe Cache
+        $cachedResponse = $this->cache->get($cacheKey);
+        if ($cachedResponse instanceof ClientResponse) {
+            return $cachedResponse;
+        }
+
+        // Response holen und cachen
+        $response = $next($request);
+
+        if ($response->isSuccessful()) {
+            $ttl = $this->calculateTtl($response);
+            $this->cache->set($cacheKey, $response, $ttl);
+        }
+
+        return $response;
+    }
+
+    private function generateCacheKey(ClientRequest $request): string
+    {
+        return 'http_client_' . md5($request->url . serialize($request->headers->all()));
+    }
+
+    private function calculateTtl(ClientResponse $response): int
+    {
+        $cacheControl = $response->headers->get('Cache-Control')[0] ?? '';;
+
+        if ($cacheControl && preg_match('/max-age=(\d+)/', $cacheControl, $matches)) {
+            return (int) $matches[1];
+        }
+
+        return $this->defaultTtl;
+    }
+}
diff --git a/src/Framework/HttpClient/Middleware/LoggingMiddleware.php b/src/Framework/HttpClient/Middleware/LoggingMiddleware.php
new file mode 100644
index 00000000..057a45c4
--- /dev/null
+++ b/src/Framework/HttpClient/Middleware/LoggingMiddleware.php
@@ -0,0 +1,54 @@
+<?php
+
+namespace App\Framework\HttpClient\Middleware;
+
+use App\Framework\HttpClient\ClientRequest;
+use App\Framework\HttpClient\ClientResponse;
+use App\Framework\HttpClient\HttpClientMiddleware;
+use App\Framework\Logging\Logger;
+
+final readonly class LoggingMiddleware implements HttpClientMiddleware
+{
+    public function __construct(
+        private Logger $logger
+    )
+    {
+    }
+
+    public function __invoke(ClientRequest $request, callable $next): ClientResponse
+    {
+        $startTime = microtime(true);
+
+        $this->logger->info('HTTP Request', [
+            'method' => $request->method->value,
+            'url' => $request->url,
+            'headers' => $request->headers->all(),
+        ]);
+
+        try {
+            $response = $next($request);
+
+            $duration = microtime(true) - $startTime;
+
+            $this->logger->info('HTTP Response', [
+                'status' => $response->status->value,
+                'duration' => $duration,
+                'headers' => $response->headers->all(),
+            ]);
+
+            return $response;
+
+        } catch (\Throwable $e) {
+            $duration = microtime(true) - $startTime;
+
+            $this->logger->error('HTTP Request Failed', [
+                'method' => $request->method->value,
+                'url' => $request->url,
+                'duration' => $duration,
+                'error' => $e->getMessage(),
+            ]);
+
+            throw $e;
+        }
+    }
+}
diff --git a/src/Framework/HttpClient/Middleware/RateLimitingMiddleware.php b/src/Framework/HttpClient/Middleware/RateLimitingMiddleware.php
new file mode 100644
index 00000000..96d79436
--- /dev/null
+++ b/src/Framework/HttpClient/Middleware/RateLimitingMiddleware.php
@@ -0,0 +1,48 @@
+<?php
+
+namespace App\Framework\HttpClient\Middleware;
+
+use App\Framework\HttpClient\ClientRequest;
+use App\Framework\HttpClient\ClientResponse;
+use App\Framework\HttpClient\HttpClientMiddleware;
+
+final class RateLimitingMiddleware implements HttpClientMiddleware
+{
+    private array $lastRequestTimes = [];
+
+    public function __construct(
+        private readonly int $maxRequests = 10,
+        private readonly int $windowSeconds = 60
+    ) {}
+
+    public function __invoke(ClientRequest $request, callable $next): ClientResponse
+    {
+        $host = parse_url($request->url, PHP_URL_HOST);
+        $now = time();
+
+        if (!isset($this->lastRequestTimes[$host])) {
+            $this->lastRequestTimes[$host] = [];
+        }
+
+        // Alte Requests aus dem Window entfernen
+        $this->lastRequestTimes[$host] = array_filter(
+            $this->lastRequestTimes[$host],
+            fn($time) => $now - $time < $this->windowSeconds
+        );
+
+        // Rate-Limit prüfen
+        if (count($this->lastRequestTimes[$host]) >= $this->maxRequests) {
+            $oldestRequest = min($this->lastRequestTimes[$host]);
+            $waitTime = $this->windowSeconds - ($now - $oldestRequest);
+
+            if ($waitTime > 0) {
+                sleep($waitTime);
+            }
+        }
+
+        // Request-Zeit erfassen
+        $this->lastRequestTimes[$host][] = $now;
+
+        return $next($request);
+    }
+}
diff --git a/src/Framework/HttpClient/Middleware/RetryMiddleware.php b/src/Framework/HttpClient/Middleware/RetryMiddleware.php
new file mode 100644
index 00000000..b8ff3e7e
--- /dev/null
+++ b/src/Framework/HttpClient/Middleware/RetryMiddleware.php
@@ -0,0 +1,53 @@
+<?php
+
+namespace App\Framework\HttpClient\Middleware;
+
+use App\Framework\HttpClient\ClientRequest;
+use App\Framework\HttpClient\ClientResponse;
+use App\Framework\HttpClient\HttpClientMiddleware;
+
+final readonly class RetryMiddleware implements HttpClientMiddleware
+{
+    public function __construct(
+        private int   $maxRetries = 3,
+        private float $baseDelay = 1.0,
+        private array $retryableStatuses = [500, 502, 503, 504]
+    ) {}
+
+    public function __invoke(ClientRequest $request, callable $next): ClientResponse
+    {
+        $attempt = 0;
+
+        while ($attempt <= $this->maxRetries) {
+            try {
+                $response = $next($request);
+
+                // Erfolgreich oder nicht wiederholbar
+                if ($response->isSuccessful() || !in_array($response->status->value, $this->retryableStatuses)) {
+                    return $response;
+                }
+
+                // Letzter Versuch
+                if ($attempt === $this->maxRetries) {
+                    return $response;
+                }
+
+                // Exponential backoff
+                $delay = $this->baseDelay * (2 ** $attempt);
+                usleep((int) ($delay * 1000000));
+
+            } catch (\Throwable $e) {
+                if ($attempt === $this->maxRetries) {
+                    throw $e;
+                }
+
+                $delay = $this->baseDelay * (2 ** $attempt);
+                usleep((int) ($delay * 1000000));
+            }
+
+            $attempt++;
+        }
+
+        return $next($request);
+    }
+}
diff --git a/src/Framework/HttpClient/RequestValidator.php b/src/Framework/HttpClient/RequestValidator.php
new file mode 100644
index 00000000..f8523bb2
--- /dev/null
+++ b/src/Framework/HttpClient/RequestValidator.php
@@ -0,0 +1,79 @@
+<?php
+
+namespace App\Framework\HttpClient;
+
+use App\Framework\HttpClient\Exception\RequestValidationException;
+
+final readonly class RequestValidator
+{
+    public function validate(ClientRequest $request): void
+    {
+        $this->validateUrl($request->url);
+        $this->validateMethod($request->method);
+        $this->validateHeaders($request->headers);
+        $this->validateBody($request->body, $request->method);
+        $this->validateOptions($request->options);
+    }
+
+    private function validateUrl(string $url): void
+    {
+        if (empty($url)) {
+            throw new RequestValidationException('URL cannot be empty');
+        }
+
+        if (!filter_var($url, FILTER_VALIDATE_URL)) {
+            throw new RequestValidationException("Invalid URL format: $url");
+        }
+
+        $scheme = parse_url($url, PHP_URL_SCHEME);
+        if (!in_array($scheme, ['http', 'https'])) {
+            throw new RequestValidationException("Unsupported URL scheme: $scheme");
+        }
+    }
+
+    private function validateMethod(\App\Framework\Http\Method $method): void
+    {
+        // Bereits durch Enum validiert, aber zusätzliche Checks möglich
+        if (in_array($method, [\App\Framework\Http\Method::TRACE, \App\Framework\Http\Method::CONNECT])) {
+            throw new RequestValidationException("Method {$method->value} is not supported");
+        }
+    }
+
+    private function validateHeaders(\App\Framework\Http\Headers $headers): void
+    {
+        foreach ($headers->all() as $name => $value) {
+            if (empty($name)) {
+                throw new RequestValidationException('Header name cannot be empty');
+            }
+
+            if (preg_match('/[^\x21-\x7E\x80-\xFF]/', $name)) {
+                throw new RequestValidationException("Invalid header name: $name");
+            }
+        }
+    }
+
+    private function validateBody(string|array $body, \App\Framework\Http\Method $method): void
+    {
+        // GET und HEAD sollten keinen Body haben
+        if (in_array($method, [\App\Framework\Http\Method::GET, \App\Framework\Http\Method::HEAD])) {
+            if (!empty($body)) {
+                throw new RequestValidationException("Method {$method->value} should not have a body");
+            }
+        }
+    }
+
+    private function validateOptions(ClientOptions $options): void
+    {
+        if ($options->timeout <= 0) {
+            throw new RequestValidationException('Timeout must be positive');
+        }
+
+        if ($options->connectTimeout <= 0) {
+            throw new RequestValidationException('Connect timeout must be positive');
+        }
+
+        if ($options->maxRedirects < 0) {
+            throw new RequestValidationException('Max redirects cannot be negative');
+        }
+    }
+}
diff --git a/src/Framework/HttpClient/ResponseValidator.php b/src/Framework/HttpClient/ResponseValidator.php
new file mode 100644
index 00000000..525f66ac
--- /dev/null
+++ b/src/Framework/HttpClient/ResponseValidator.php
@@ -0,0 +1,32 @@
+<?php
+
+namespace App\Framework\HttpClient;
+
+use App\Framework\HttpClient\Exception\ResponseValidationException;
+
+class ResponseValidator
+{
+    public function validate(ClientResponse $response, ClientOptions $options): void
+    {
+        if ($options->throwOnError && !$response->isSuccessful()) {
+            $this->throwHttpException($response);
+        }
+
+        if (!empty($options->allowedStatusCodes) && !in_array($response->status->value, $options->allowedStatusCodes)) {
+            throw new ResponseValidationException(
+                "Status code {$response->status->value} is not in allowed codes: " . implode(', ', $options->allowedStatusCodes)
+            );
+        }
+    }
+
+    private function throwHttpException(ClientResponse $response): void
+    {
+        $message = "HTTP {$response->status->value}: {$response->status->name}";
+
+        if ($response->isClientError()) {
+            throw new \App\Framework\HttpClient\Exception\ClientErrorException($message, $response);
+        } elseif ($response->isServerError()) {
+            throw new \App\Framework\HttpClient\Exception\ServerErrorException($message, $response);
+        }
+    }
+}
diff --git a/src/Framework/Logging/DefaultLogger.php b/src/Framework/Logging/DefaultLogger.php
new file mode 100644
index 00000000..f026bf3a
--- /dev/null
+++ b/src/Framework/Logging/DefaultLogger.php
@@ -0,0 +1,107 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Logging;
+
+use App\Framework\Attributes\Singleton;
+use App\Framework\Logging\Handlers\ConsoleHandler;
+use DateTimeZone;
+
+/**
+ * Einfacher Logger für das Framework.
+ */
+#[Singleton]
+final readonly class DefaultLogger implements Logger
+{
+    /**
+     * @param LogLevel $minLevel Minimales Level, das geloggt werden soll
+     * @param array<LogHandler> $handlers Array von Log-Handlern
+     * @param ProcessorManager $processorManager Optional: Processor Manager für die Verarbeitung
+     */
+    public function __construct(
+        private LogLevel         $minLevel = LogLevel::DEBUG,
+        /** @var LogHandler[] */
+        private array            $handlers = [],
+        private ProcessorManager $processorManager = new ProcessorManager(),
+    ) {}
+
+    public function debug(string $message, array $context = []): void
+    {
+        $this->log(LogLevel::DEBUG, $message, $context);
+    }
+
+    public function info(string $message, array $context = []): void
+    {
+        $this->log(LogLevel::INFO, $message, $context);
+    }
+
+    public function notice(string $message, array $context = []): void
+    {
+        $this->log(LogLevel::NOTICE, $message, $context);
+    }
+
+    public function warning(string $message, array $context = []): void
+    {
+        $this->log(LogLevel::WARNING, $message, $context);
+    }
+
+    public function error(string $message, array $context = []): void
+    {
+        $this->log(LogLevel::ERROR, $message, $context);
+    }
+
+    public function critical(string $message, array $context = []): void
+    {
+        $this->log(LogLevel::CRITICAL, $message, $context);
+    }
+
+    public function alert(string $message, array $context = []): void
+    {
+        $this->log(LogLevel::ALERT, $message, $context);
+    }
+
+    public function emergency(string $message, array $context = []): void
+    {
+        $this->log(LogLevel::EMERGENCY, $message, $context);
+    }
+
+    /**
+     * Log-Nachricht mit beliebigem Level erstellen
+     *
+     * @param LogLevel $level Log-Level
+     * @param string $message Log-Nachricht
+     * @param array $context Kontext-Daten für Platzhalter-Ersetzung
+     */
+    public function log(LogLevel $level, string $message, array $context = []): void
+    {
+        // Log-Record erstellen
+        $record = new LogRecord(
+            message: $message,
+            context: $context,
+            level: $level,
+            timestamp: new \DateTimeImmutable(timezone: new DateTimeZone('Europe/Berlin')),
+        );
+
+        // Record durch alle Processors verarbeiten
+        $processedRecord = $this->processorManager->processRecord($record);
+
+        // Alle Handler durchlaufen
+        foreach ($this->handlers as $handler) {
+            if ($handler->isHandling($processedRecord)) {
+                $handler->handle($processedRecord);
+            }
+        }
+    }
+
+    /**
+     * Gibt die aktuelle Konfiguration des Loggers zurück
+     */
+    public function getConfiguration(): array
+    {
+        return [
+            'minLevel' => $this->minLevel->value,
+            'handlers' => array_map(fn(LogHandler $h) => get_class($h), $this->handlers),
+            'processors' => $this->processorManager->getProcessorList(),
+        ];
+    }
+}
diff --git a/src/Framework/Logging/Handlers/ConsoleHandler.php b/src/Framework/Logging/Handlers/ConsoleHandler.php
new file mode 100644
index 00000000..5b7495d6
--- /dev/null
+++ b/src/Framework/Logging/Handlers/ConsoleHandler.php
@@ -0,0 +1,123 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Logging\Handlers;
+
+use App\Framework\Console\ConsoleColor;
+use App\Framework\Logging\LogHandler;
+use App\Framework\Logging\LogLevel;
+use App\Framework\Logging\LogRecord;
+
+/**
+ * Handler für die Ausgabe von Log-Einträgen in der Konsole.
+ */
+class ConsoleHandler implements LogHandler
+{
+    /**
+     * @var LogLevel Minimales Level, ab dem dieser Handler aktiv wird
+     */
+    private LogLevel $minLevel;
+
+    /**
+     * @var bool Ob der Handler nur im Debug-Modus aktiv ist
+     */
+    private bool $debugOnly;
+
+    /**
+     * @var string Format für die Ausgabe
+     */
+    private string $outputFormat;
+
+    /**
+     * Erstellt einen neuen ConsoleHandler
+     *
+     * @param LogLevel|int $minLevel Minimales Level, ab dem dieser Handler aktiv wird
+     * @param bool $debugOnly Ob der Handler nur im Debug-Modus aktiv ist
+     * @param string $outputFormat Format für die Ausgabe
+     */
+    public function __construct(
+        LogLevel|int $minLevel = LogLevel::DEBUG,
+        bool $debugOnly = true,
+        string $outputFormat = '{color}[{level_name}]{reset} {timestamp} {request_id}{message}',
+        private LogLevel $stderrLevel = LogLevel::WARNING,
+    ) {
+        $this->minLevel = $minLevel instanceof LogLevel ? $minLevel : LogLevel::fromValue($minLevel);
+        $this->debugOnly = $debugOnly;
+        $this->outputFormat = $outputFormat;
+    }
+
+    /**
+     * Überprüft, ob dieser Handler den Log-Eintrag verarbeiten soll
+     */
+    public function isHandling(LogRecord $record): bool
+    {
+        // Nur im CLI-Modus aktiv - NIE bei Web-Requests!
+        if (PHP_SAPI !== 'cli') {
+            return false;
+        }
+
+        // Optional: Debug-Modus-Check nur in CLI
+        if ($this->debugOnly && !filter_var(getenv('APP_DEBUG'), FILTER_VALIDATE_BOOLEAN)) {
+            return false;
+        }
+
+
+        return $record->getLevel()->value >= $this->minLevel->value;
+    }
+
+    /**
+     * Verarbeitet einen Log-Eintrag
+     */
+    public function handle(LogRecord $record): void
+    {
+        $logLevel = $record->getLevel();
+        $color = $logLevel->getConsoleColor()->value;
+        $reset = ConsoleColor::RESET->value;
+
+        // Request-ID-Teil erstellen, falls vorhanden
+        $requestId = $record->hasExtra('request_id')
+            ? "[{$record->getExtra('request_id')}] "
+            : '';
+
+        // Werte für Platzhalter im Format
+        $values = [
+            '{color}' => $color,
+            '{reset}' => $reset,
+            '{level_name}' => $record->getLevel()->getName(),
+            '{timestamp}' => $record->getFormattedTimestamp(),
+            '{request_id}' => $requestId,
+            '{message}' => $record->getMessage(),
+            '{channel}' => $record->getChannel() ? "[{$record->getChannel()}] " : '',
+        ];
+
+        // Formatierte Ausgabe erstellen
+        $output = strtr($this->outputFormat, $values) . PHP_EOL;
+
+        // Fehler und Warnungen auf stderr, alles andere auf stdout
+        if ($record->getLevel()->value >= $this->stderrLevel->value) {
+            // WARNING, ERROR, CRITICAL, ALERT, EMERGENCY -> stderr
+            file_put_contents('php://stderr', $output);
+        } else {
+            // DEBUG, INFO, NOTICE -> stdout
+            echo $output;
+        }
+    }
+
+    /**
+     * Minimales Log-Level setzen
+     */
+    public function setMinLevel(LogLevel|int $level): self
+    {
+        $this->minLevel = $level instanceof LogLevel ? $level : LogLevel::fromValue($level);
+        return $this;
+    }
+
+    /**
+     * Ausgabeformat setzen
+     */
+    public function setOutputFormat(string $format): self
+    {
+        $this->outputFormat = $format;
+        return $this;
+    }
+}
diff --git a/src/Framework/Logging/Handlers/FileHandler.php b/src/Framework/Logging/Handlers/FileHandler.php
new file mode 100644
index 00000000..258977cb
--- /dev/null
+++ b/src/Framework/Logging/Handlers/FileHandler.php
@@ -0,0 +1,157 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Logging\Handlers;
+
+use App\Framework\Logging\LogHandler;
+use App\Framework\Logging\LogLevel;
+use App\Framework\Logging\LogRecord;
+
+/**
+ * Handler für die Ausgabe von Log-Einträgen in Dateien.
+ */
+class FileHandler implements LogHandler
+{
+    /**
+     * @var LogLevel Minimales Level, ab dem dieser Handler aktiv wird
+     */
+    private LogLevel $minLevel;
+
+    /**
+     * @var string Pfad zur Log-Datei
+     */
+    private string $logFile;
+
+    /**
+     * @var string Format für die Ausgabe
+     */
+    private string $outputFormat;
+
+    /**
+     * @var int Datei-Modi für die Log-Datei
+     */
+    private int $fileMode;
+
+    /**
+     * Erstellt einen neuen FileHandler
+     *
+     * @param string $logFile Pfad zur Log-Datei
+     * @param LogLevel|int $minLevel Minimales Level, ab dem dieser Handler aktiv wird
+     * @param string $outputFormat Format für die Ausgabe
+     * @param int $fileMode Datei-Modi für die Log-Datei
+     */
+    public function __construct(
+        string $logFile,
+        LogLevel|int $minLevel = LogLevel::DEBUG,
+        string $outputFormat = '[{timestamp}] [{level_name}] {request_id}{channel}{message}',
+        int $fileMode = 0644
+    ) {
+        $this->logFile = $logFile;
+        $this->minLevel = $minLevel instanceof LogLevel ? $minLevel : LogLevel::fromValue($minLevel);
+        $this->outputFormat = $outputFormat;
+        $this->fileMode = $fileMode;
+
+        // Stelle sicher, dass das Verzeichnis existiert
+        $this->ensureDirectoryExists(dirname($logFile));
+    }
+
+    /**
+     * Überprüft, ob dieser Handler den Log-Eintrag verarbeiten soll
+     */
+    public function isHandling(LogRecord $record): bool
+    {
+        return $record->getLevel()->value >= $this->minLevel->value;
+    }
+
+    /**
+     * Verarbeitet einen Log-Eintrag
+     */
+    public function handle(LogRecord $record): void
+    {
+        // Request-ID-Teil erstellen, falls vorhanden
+        $requestId = $record->hasExtra('request_id')
+            ? "[{$record->getExtra('request_id')}] "
+            : '';
+
+        // Channel-Teil erstellen, falls vorhanden
+        $channel = $record->getChannel()
+            ? "[{$record->getChannel()}] "
+            : '';
+
+        // Werte für Platzhalter im Format
+        $values = [
+            '{level_name}' => $record->getLevel()->getName(),
+            '{timestamp}' => $record->getFormattedTimestamp(),
+            '{request_id}' => $requestId,
+            '{channel}' => $channel,
+            '{message}' => $record->getMessage(),
+        ];
+
+        // Formatierte Ausgabe erstellen
+        $output = strtr($this->outputFormat, $values) . PHP_EOL;
+
+        // In die Datei schreiben
+        $this->write($output);
+
+        // Bei kritischen Fehlern Cache leeren, um sicherzustellen, dass der Eintrag geschrieben wird
+        if ($record->getLevel()->value >= LogLevel::CRITICAL->value) {
+            $this->flush();
+        }
+    }
+
+    /**
+     * Schreibt einen String in die Log-Datei
+     */
+    protected function write(string $output): void
+    {
+        file_put_contents($this->logFile, $output, FILE_APPEND);
+    }
+
+    /**
+     * Leert Cache und stellt sicher, dass alles geschrieben wurde
+     */
+    protected function flush(): void
+    {
+        if (function_exists('opcache_reset')) {
+            opcache_reset();
+        }
+    }
+
+    /**
+     * Stellt sicher, dass ein Verzeichnis existiert
+     */
+    private function ensureDirectoryExists(string $dir): void
+    {
+        if (!file_exists($dir)) {
+            mkdir($dir, 0777, true);
+        }
+    }
+
+    /**
+     * Minimales Log-Level setzen
+     */
+    public function setMinLevel(LogLevel|int $level): self
+    {
+        $this->minLevel = $level instanceof LogLevel ? $level : LogLevel::fromValue($level);
+        return $this;
+    }
+
+    /**
+     * Ausgabeformat setzen
+     */
+    public function setOutputFormat(string $format): self
+    {
+        $this->outputFormat = $format;
+        return $this;
+    }
+
+    /**
+     * Log-Datei setzen
+     */
+    public function setLogFile(string $logFile): self
+    {
+        $this->logFile = $logFile;
+        $this->ensureDirectoryExists(dirname($logFile));
+        return $this;
+    }
+}
diff --git a/src/Framework/Logging/Handlers/JsonFileHandler.php b/src/Framework/Logging/Handlers/JsonFileHandler.php
new file mode 100644
index 00000000..0fc306b9
--- /dev/null
+++ b/src/Framework/Logging/Handlers/JsonFileHandler.php
@@ -0,0 +1,137 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Logging\Handlers;
+
+use App\Framework\Logging\LogHandler;
+use App\Framework\Logging\LogLevel;
+use App\Framework\Logging\LogRecord;
+
+/**
+ * Handler für die Ausgabe von Log-Einträgen als JSON in Dateien.
+ * Besonders nützlich für maschinelle Verarbeitung und Log-Aggregatoren.
+ */
+class JsonFileHandler implements LogHandler
+{
+    /**
+     * @var LogLevel Minimales Level, ab dem dieser Handler aktiv wird
+     */
+    private LogLevel $minLevel;
+
+    /**
+     * @var string Pfad zur Log-Datei
+     */
+    private string $logFile;
+
+    /**
+     * @var array Liste der Felder, die in der JSON-Ausgabe enthalten sein sollen
+     */
+    private array $includedFields;
+
+    /**
+     * Erstellt einen neuen JsonFileHandler
+     *
+     * @param string $logFile Pfad zur Log-Datei
+     * @param LogLevel|int $minLevel Minimales Level, ab dem dieser Handler aktiv wird
+     * @param array|null $includedFields Liste der Felder, die in der JSON-Ausgabe enthalten sein sollen (null = alle)
+     */
+    public function __construct(
+        string $logFile,
+        LogLevel|int $minLevel = LogLevel::INFO,
+        ?array $includedFields = null
+    ) {
+        $this->logFile = $logFile;
+        $this->minLevel = $minLevel instanceof LogLevel ? $minLevel : LogLevel::fromValue($minLevel);
+
+        // Standardfelder, falls nicht anders angegeben
+        $this->includedFields = $includedFields ?? [
+            'timestamp',
+            'level_name',
+            'message',
+            'context',
+            'extra',
+            'channel',
+        ];
+
+        // Stelle sicher, dass das Verzeichnis existiert
+        $this->ensureDirectoryExists(dirname($logFile));
+    }
+
+    /**
+     * Überprüft, ob dieser Handler den Log-Eintrag verarbeiten soll
+     */
+    public function isHandling(LogRecord $record): bool
+    {
+        return $record->getLevel()->value >= $this->minLevel->value;
+    }
+
+    /**
+     * Verarbeitet einen Log-Eintrag
+     */
+    public function handle(LogRecord $record): void
+    {
+        // Alle Daten des Records als Array holen
+        $data = $record->toArray();
+
+        // Nur die gewünschten Felder behalten
+        if (!empty($this->includedFields)) {
+            $data = array_intersect_key($data, array_flip($this->includedFields));
+        }
+
+        // Zeitstempel als ISO 8601 formatieren für bessere Interoperabilität
+        if (isset($data['datetime']) && $data['datetime'] instanceof \DateTimeInterface) {
+            $data['timestamp_iso'] = $data['datetime']->format(\DateTimeInterface::ATOM);
+            unset($data['datetime']); // DateTime-Objekt entfernen
+        }
+
+        // Als JSON formatieren und in die Datei schreiben
+        $json = json_encode($data, JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES | JSON_PARTIAL_OUTPUT_ON_ERROR) . PHP_EOL;
+        $this->write($json);
+    }
+
+    /**
+     * Schreibt einen String in die Log-Datei
+     */
+    protected function write(string $output): void
+    {
+        file_put_contents($this->logFile, $output, FILE_APPEND);
+    }
+
+    /**
+     * Stellt sicher, dass ein Verzeichnis existiert
+     */
+    private function ensureDirectoryExists(string $dir): void
+    {
+        if (!file_exists($dir)) {
+            mkdir($dir, 0777, true);
+        }
+    }
+
+    /**
+     * Minimales Log-Level setzen
+     */
+    public function setMinLevel(LogLevel|int $level): self
+    {
+        $this->minLevel = $level instanceof LogLevel ? $level : LogLevel::fromValue($level);
+        return $this;
+    }
+
+    /**
+     * Setzt die Liste der Felder, die in der JSON-Ausgabe enthalten sein sollen
+     */
+    public function setIncludedFields(array $fields): self
+    {
+        $this->includedFields = $fields;
+        return $this;
+    }
+
+    /**
+     * Log-Datei setzen
+     */
+    public function setLogFile(string $logFile): self
+    {
+        $this->logFile = $logFile;
+        $this->ensureDirectoryExists(dirname($logFile));
+        return $this;
+    }
+}
diff --git a/src/Framework/Logging/Handlers/QueuedLogHandler.php b/src/Framework/Logging/Handlers/QueuedLogHandler.php
new file mode 100644
index 00000000..7b5ab521
--- /dev/null
+++ b/src/Framework/Logging/Handlers/QueuedLogHandler.php
@@ -0,0 +1,29 @@
+<?php
+
+namespace App\Framework\Logging\Handlers;
+
+use App\Framework\Database\DatabaseManager;
+use App\Framework\Logging\LogHandler;
+use App\Framework\Logging\LogLevel;
+use App\Framework\Logging\LogRecord;
+use App\Framework\Logging\ProcessLogCommand;
+use App\Framework\Queue\Queue;
+
+final readonly class QueuedLogHandler implements LogHandler
+{
+    public function __construct(
+        private Queue $queue,
+        #private LogLevel $minLevel = LogLevel::INFO,
+    ){}
+
+    public function isHandling(LogRecord $record): bool
+    {
+        return true;
+    }
+
+    public function handle(LogRecord $record): void
+    {
+        $job = new ProcessLogCommand($record);
+        $this->queue->push($job);
+    }
+}
diff --git a/src/Framework/Logging/Handlers/SyslogHandler.php b/src/Framework/Logging/Handlers/SyslogHandler.php
new file mode 100644
index 00000000..a1a8676a
--- /dev/null
+++ b/src/Framework/Logging/Handlers/SyslogHandler.php
@@ -0,0 +1,95 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Logging\Handlers;
+
+use App\Framework\Logging\LogHandler;
+use App\Framework\Logging\LogLevel;
+use App\Framework\Logging\LogRecord;
+
+/**
+ * Handler für Syslog-basiertes Logging
+ */
+final class SyslogHandler implements LogHandler
+{
+    private bool $isOpen = false;
+
+    public function __construct(
+        private readonly string   $ident = 'php-app',
+        private readonly int      $facility = LOG_USER,
+        private readonly LogLevel $minLevel = LogLevel::DEBUG
+    ) {}
+
+    public function isHandling(LogRecord $record): bool
+    {
+        return $record->getLevel()->value >= $this->minLevel->value;
+    }
+
+    public function handle(LogRecord $record): void
+    {
+        $this->openSyslog();
+
+        $priority = $this->mapLogLevelToSyslogPriority($record->getLevel());
+        $message = $this->formatMessage($record);
+
+        syslog($priority, $message);
+    }
+
+    private function openSyslog(): void
+    {
+        if (!$this->isOpen) {
+            openlog($this->ident, LOG_PID | LOG_PERROR, $this->facility);
+            $this->isOpen = true;
+        }
+    }
+
+    private function formatMessage(LogRecord $record): string
+    {
+        $parts = [];
+
+        // Request-ID falls vorhanden
+        if ($record->hasExtra('request_id')) {
+            $parts[] = "[{$record->getExtra('request_id')}]";
+        }
+
+        // Channel falls vorhanden
+        if ($record->getChannel()) {
+            $parts[] = "[{$record->getChannel()}]";
+        }
+
+        // Hauptnachricht
+        $parts[] = $record->getMessage();
+
+        // Context-Daten falls vorhanden
+        $context = $record->getContext();
+        if (!empty($context)) {
+            $parts[] = 'Context: ' . json_encode($context, JSON_UNESCAPED_SLASHES);
+        }
+
+        return implode(' ', $parts);
+    }
+
+    /**
+     * Mappt Framework LogLevel auf Syslog-Prioritäten
+     */
+    private function mapLogLevelToSyslogPriority(LogLevel $level): int
+    {
+        return match ($level) {
+            LogLevel::EMERGENCY => LOG_EMERG,
+            LogLevel::ALERT => LOG_ALERT,
+            LogLevel::CRITICAL => LOG_CRIT,
+            LogLevel::ERROR => LOG_ERR,
+            LogLevel::WARNING => LOG_WARNING,
+            LogLevel::NOTICE => LOG_NOTICE,
+            LogLevel::INFO => LOG_INFO,
+            LogLevel::DEBUG => LOG_DEBUG,
+        };
+    }
+
+    public function __destruct()
+    {
+        if ($this->isOpen) {
+            closelog();
+        }
+    }
+}
diff --git a/src/Framework/Logging/Handlers/WebHandler.php b/src/Framework/Logging/Handlers/WebHandler.php
new file mode 100644
index 00000000..311455c5
--- /dev/null
+++ b/src/Framework/Logging/Handlers/WebHandler.php
@@ -0,0 +1,66 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Logging\Handlers;
+
+use App\Framework\Logging\LogHandler;
+use App\Framework\Logging\LogLevel;
+use App\Framework\Logging\LogRecord;
+
+final class WebHandler implements LogHandler
+{
+    public function __construct(
+        private readonly LogLevel $minLevel = LogLevel::DEBUG,
+        private readonly bool $debugOnly = true
+    ) {}
+
+    public function isHandling(LogRecord $record): bool
+    {
+        // Nur bei Web-Requests (nicht CLI)
+        if (PHP_SAPI === 'cli') {
+            return false;
+        }
+
+        // Debug-Modus-Check
+        if ($this->debugOnly && !filter_var(getenv('APP_DEBUG'), FILTER_VALIDATE_BOOLEAN)) {
+            return false;
+        }
+
+        return $record->getLevel()->value >= $this->minLevel->value;
+    }
+
+    public function handle(LogRecord $record): void
+    {
+        $timestamp = $record->getFormattedTimestamp();
+        $level = $record->getLevel()->getName();
+        $message = $record->getMessage();
+        $channel = $record->getChannel();
+
+        // Request-ID falls vorhanden
+        $requestId = $record->hasExtra('request_id')
+            ? "[{$record->getExtra('request_id')}] "
+            : '';
+
+        // Channel falls vorhanden
+        $channelPrefix = $channel ? "[$channel] " : '';
+
+        $logLine = sprintf(
+            '[%s] %s[%s] %s%s',
+            $timestamp,
+            $requestId,
+            $level,
+            $channelPrefix,
+            $message
+        );
+
+        // Context-Daten falls vorhanden
+        $context = $record->getContext();
+        if (!empty($context)) {
+            $logLine .= ' | Context: ' . json_encode($context, JSON_UNESCAPED_SLASHES);
+        }
+
+        // In error_log schreiben
+        error_log($logLine);
+    }
+
+}
diff --git a/src/Framework/Logging/LogHandler.php b/src/Framework/Logging/LogHandler.php
new file mode 100644
index 00000000..c0286aab
--- /dev/null
+++ b/src/Framework/Logging/LogHandler.php
@@ -0,0 +1,20 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Logging;
+
+/**
+ * Interface für Log-Handler, die Log-Einträge verarbeiten.
+ */
+interface LogHandler
+{
+    /**
+     * Überprüft, ob dieser Handler den Log-Eintrag verarbeiten soll
+     */
+    public function isHandling(LogRecord $record): bool;
+
+    /**
+     * Verarbeitet einen Log-Eintrag
+     */
+    public function handle(LogRecord $record): void;
+}
diff --git a/src/Framework/Logging/LogLevel.php b/src/Framework/Logging/LogLevel.php
new file mode 100644
index 00000000..fdafc418
--- /dev/null
+++ b/src/Framework/Logging/LogLevel.php
@@ -0,0 +1,73 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Logging;
+
+use App\Framework\Console\ConsoleColor;
+
+/**
+ * Enum für Log-Level mit zugehörigen Werten und Namen.
+ */
+enum LogLevel: int
+{
+    case DEBUG = 100;
+    case INFO = 200;
+    case NOTICE = 250;
+    case WARNING = 300;
+    case ERROR = 400;
+    case CRITICAL = 500;
+    case ALERT = 550;
+    case EMERGENCY = 600;
+
+    /**
+     * Gibt den Namen des Log-Levels zurück.
+     */
+    public function getName(): string
+    {
+        return match($this) {
+            self::DEBUG => 'DEBUG',
+            self::INFO => 'INFO',
+            self::NOTICE => 'NOTICE',
+            self::WARNING => 'WARNING',
+            self::ERROR => 'ERROR',
+            self::CRITICAL => 'CRITICAL',
+            self::ALERT => 'ALERT',
+            self::EMERGENCY => 'EMERGENCY',
+        };
+    }
+
+    /**
+     * Gibt die Farbe für die Konsole zurück.
+     */
+    public function getConsoleColor(): ConsoleColor
+    {
+        return match($this) {
+            self::DEBUG => ConsoleColor::GRAY,
+            self::INFO => ConsoleColor::GREEN,
+            self::NOTICE => ConsoleColor::CYAN,
+            self::WARNING => ConsoleColor::YELLOW,
+            self::ERROR => ConsoleColor::RED,
+            self::CRITICAL => ConsoleColor::MAGENTA,
+            self::ALERT => ConsoleColor::WHITE_ON_RED,
+            self::EMERGENCY => ConsoleColor::BLACK_ON_YELLOW,
+        };
+    }
+
+    /**
+     * Erstellt ein LogLevel aus einem Integer-Wert.
+     * Gibt das nächstniedrigere Level zurück, wenn der exakte Wert nicht existiert.
+     */
+    public static function fromValue(int $value): self
+    {
+        return match(true) {
+            $value >= self::EMERGENCY->value => self::EMERGENCY,
+            $value >= self::ALERT->value => self::ALERT,
+            $value >= self::CRITICAL->value => self::CRITICAL,
+            $value >= self::ERROR->value => self::ERROR,
+            $value >= self::WARNING->value => self::WARNING,
+            $value >= self::NOTICE->value => self::NOTICE,
+            $value >= self::INFO->value => self::INFO,
+            default => self::DEBUG,
+        };
+    }
+}
diff --git a/src/Framework/Logging/LogProcessor.php b/src/Framework/Logging/LogProcessor.php
new file mode 100644
index 00000000..2e8fb39c
--- /dev/null
+++ b/src/Framework/Logging/LogProcessor.php
@@ -0,0 +1,25 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Logging;
+
+/**
+ * Interface für Log-Processors, die Log-Einträge vor dem Handling verarbeiten.
+ */
+interface LogProcessor
+{
+    /**
+     * Verarbeitet einen Log-Record und gibt den modifizierten Record zurück
+     */
+    public function processRecord(LogRecord $record): LogRecord;
+
+    /**
+     * Gibt die Priorität des Processors zurück (höhere Werte = frühere Ausführung)
+     */
+    public function getPriority(): int;
+
+    /**
+     * Gibt einen eindeutigen Namen für den Processor zurück
+     */
+    public function getName(): string;
+}
diff --git a/src/Framework/Logging/LogRecord.php b/src/Framework/Logging/LogRecord.php
new file mode 100644
index 00000000..a48c950c
--- /dev/null
+++ b/src/Framework/Logging/LogRecord.php
@@ -0,0 +1,162 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Logging;
+
+/**
+ * Repräsentiert einen einzelnen Log-Eintrag mit allen relevanten Informationen.
+ */
+final class LogRecord
+{
+    /**
+     * @var array<string, mixed> Zusätzliche Daten, die dynamisch hinzugefügt werden können
+     */
+    private array $extra = [];
+
+    /**
+     * Erstellt einen neuen Log-Eintrag
+     */
+    public function __construct(
+        private string $message,
+        private array $context,
+        private LogLevel $level,
+        private \DateTimeImmutable $timestamp,
+        private ?string $channel = null
+    ) {}
+
+    /**
+     * Gibt die Log-Nachricht zurück
+     */
+    public function getMessage(): string
+    {
+        return $this->message;
+    }
+
+    /**
+     * Setzt die Log-Nachricht
+     */
+    public function setMessage(string $message): self
+    {
+        $this->message = $message;
+        return $this;
+    }
+
+    /**
+     * Gibt den Kontext zurück
+     */
+    public function getContext(): array
+    {
+        return $this->context;
+    }
+
+    /**
+     * Setzt oder erweitert den Kontext
+     */
+    public function withContext(array $context): self
+    {
+        $this->context = array_merge($this->context, $context);
+        return $this;
+    }
+
+    /**
+     * Gibt das Log-Level zurück
+     */
+    public function getLevel(): LogLevel
+    {
+        return $this->level;
+    }
+
+    /**
+     * Gibt den Zeitstempel zurück
+     */
+    public function getTimestamp(): \DateTimeImmutable
+    {
+        return $this->timestamp;
+    }
+
+    /**
+     * Gibt den formattierten Zeitstempel zurück
+     */
+    public function getFormattedTimestamp(string $format = 'Y-m-d H:i:s'): string
+    {
+        return $this->timestamp->format($format);
+    }
+
+    /**
+     * Gibt den Kanal zurück, falls gesetzt
+     */
+    public function getChannel(): ?string
+    {
+        return $this->channel;
+    }
+
+    /**
+     * Setzt den Kanal
+     */
+    public function setChannel(string $channel): self
+    {
+        $this->channel = $channel;
+        return $this;
+    }
+
+    /**
+     * Fügt einen Wert zu den Extra-Daten hinzu
+     */
+    public function addExtra(string $key, mixed $value): self
+    {
+        $this->extra[$key] = $value;
+        return $this;
+    }
+
+    /**
+     * Fügt mehrere Extra-Daten hinzu
+     */
+    public function addExtras(array $extras): self
+    {
+        foreach ($extras as $key => $value) {
+            $this->extra[$key] = $value;
+        }
+        return $this;
+    }
+
+    /**
+     * Prüft, ob ein bestimmter Extra-Wert existiert
+     */
+    public function hasExtra(string $key): bool
+    {
+        return array_key_exists($key, $this->extra);
+    }
+
+    /**
+     * Gibt einen Extra-Wert zurück
+     */
+    public function getExtra(string $key, mixed $default = null): mixed
+    {
+        return $this->extra[$key] ?? $default;
+    }
+
+    /**
+     * Gibt alle Extra-Daten zurück
+     */
+    public function getExtras(): array
+    {
+        return $this->extra;
+    }
+
+    /**
+     * Erstellt ein Array mit allen Log-Daten
+     */
+    public function toArray(): array
+    {
+        return [
+            'message' => $this->message,
+            'context' => $this->context,
+            'level' => $this->level->value,
+            'level_name' => $this->level->getName(),
+            'timestamp' => $this->getFormattedTimestamp(),
+            'datetime' => $this->timestamp,
+            'channel' => $this->channel,
+            'extra' => $this->extra,
+        ];
+    }
+}
diff --git a/src/Framework/Logging/Logger.php b/src/Framework/Logging/Logger.php
new file mode 100644
index 00000000..de1daf99
--- /dev/null
+++ b/src/Framework/Logging/Logger.php
@@ -0,0 +1,8 @@
+<?php
+
+namespace App\Framework\Logging;
+
+interface Logger
+{
+
+}
diff --git a/src/Framework/Logging/LoggerFactory.php b/src/Framework/Logging/LoggerFactory.php
new file mode 100644
index 00000000..61c57402
--- /dev/null
+++ b/src/Framework/Logging/LoggerFactory.php
@@ -0,0 +1,46 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Logging;
+
+/**
+ * Factory für Logger-Instanzen.
+ */
+final class LoggerFactory
+{
+    private static ?DefaultLogger $defaultLogger = null;
+
+    /**
+     * Erzeugt einen neuen Logger mit optionalen Einstellungen.
+     */
+    public static function create(
+        LogLevel|int $minLevel = LogLevel::DEBUG,
+        bool $enabled = true,
+        array $handlers = []
+    ): DefaultLogger {
+        return new DefaultLogger($minLevel, $enabled, $handlers);
+    }
+
+    /**
+     * Gibt den Standard-Logger zurück oder erstellt ihn, falls er noch nicht existiert.
+     */
+    public static function getDefaultLogger(): DefaultLogger
+    {
+        if (self::$defaultLogger === null) {
+            $debug = filter_var(getenv('APP_DEBUG'), FILTER_VALIDATE_BOOLEAN);
+            $minLevel = $debug ? LogLevel::DEBUG : LogLevel::INFO;
+
+            self::$defaultLogger = self::create($minLevel);
+        }
+
+        return self::$defaultLogger;
+    }
+
+    /**
+     * Setzt einen benutzerdefinierten Logger als Standard-Logger.
+     */
+    public static function setDefaultLogger(DefaultLogger $logger): void
+    {
+        self::$defaultLogger = $logger;
+    }
+}
diff --git a/src/Framework/Logging/LoggerInitializer.php b/src/Framework/Logging/LoggerInitializer.php
new file mode 100644
index 00000000..b7097c20
--- /dev/null
+++ b/src/Framework/Logging/LoggerInitializer.php
@@ -0,0 +1,44 @@
+<?php
+
+namespace App\Framework\Logging;
+
+use App\Framework\Core\PathProvider;
+use App\Framework\Database\DatabaseManager;
+use App\Framework\DI\Initializer;
+use App\Framework\Logging\Handlers\ConsoleHandler;
+use App\Framework\Logging\Handlers\FileHandler;
+use App\Framework\Logging\Handlers\QueuedLogHandler;
+use App\Framework\Logging\Handlers\WebHandler;
+use App\Framework\Queue\FileQueue;
+use App\Framework\Queue\Queue;
+use App\Framework\Queue\RedisQueue;
+
+;
+
+final readonly class LoggerInitializer
+{
+    public function __construct(
+        #private DatabaseManager $db,
+        #private PathProvider $pathProvider,
+    ){}
+
+    #[Initializer]
+    public function __invoke():Logger
+    {
+        $processorManager = new ProcessorManager();
+
+        $queue = new RedisQueue('commands', 'redis');
+        #$path = $this->pathProvider->resolvePath('/src/Framework/CommandBus/storage/queue');
+        #$queue = new FileQueue($path);
+
+        return new DefaultLogger(
+                    minLevel: LogLevel::DEBUG,
+                    handlers: [
+                        new QueuedLogHandler($queue),
+                        new ConsoleHandler(),
+                        new WebHandler(),
+                        new FileHandler('logs/app.log')],
+                    processorManager: $processorManager,
+        );
+    }
+}
diff --git a/src/Framework/Logging/ProcessLogCommand.php b/src/Framework/Logging/ProcessLogCommand.php
new file mode 100644
index 00000000..5c1d67bc
--- /dev/null
+++ b/src/Framework/Logging/ProcessLogCommand.php
@@ -0,0 +1,13 @@
+<?php
+
+namespace App\Framework\Logging;
+
+use App\Framework\Database\DatabaseManager;
+
+final readonly class ProcessLogCommand
+{
+    public function __construct(
+        public LogRecord $logData,
+    ) {}
+
+}
diff --git a/src/Framework/Logging/ProcessLogCommandHandler.php b/src/Framework/Logging/ProcessLogCommandHandler.php
new file mode 100644
index 00000000..e50cb0a5
--- /dev/null
+++ b/src/Framework/Logging/ProcessLogCommandHandler.php
@@ -0,0 +1,36 @@
+<?php
+
+namespace App\Framework\Logging;
+
+use App\Framework\CommandBus\CommandHandler;
+use App\Framework\Database\DatabaseManager;
+
+final readonly class ProcessLogCommandHandler
+{
+    public function __construct(
+        private DatabaseManager $db,
+    ){}
+
+    #[CommandHandler]
+    public function __invoke(ProcessLogCommand $commandData): void
+    {
+        $data = $commandData->logData;
+        $contextJson = json_encode($data->getContext());
+        $contextHash = hash('sha256', $contextJson);
+
+        // context_hash zur Eindeutigkeit in den Primärschlüssel aufgenommen
+        $this->db->getConnection()->execute("CREATE TABLE IF NOT EXISTS logs (timestamp TIMESTAMP, level VARCHAR(10), message VARCHAR(255), context JSON, context_hash VARCHAR(64), PRIMARY KEY (timestamp, level, message, context_hash))");
+
+        $this->db->getConnection()->execute(
+            "INSERT INTO logs (timestamp, level, message, context, context_hash) VALUES (?, ?, ?, ?, ?)",
+            [
+                $data->getFormattedTimestamp(),
+                $data->getLevel()->getName(),
+                $data->getMessage(),
+                $contextJson,
+                $contextHash,
+            ]
+        );
+
+    }
+}
diff --git a/src/Framework/Logging/ProcessorManager.php b/src/Framework/Logging/ProcessorManager.php
new file mode 100644
index 00000000..6437bafe
--- /dev/null
+++ b/src/Framework/Logging/ProcessorManager.php
@@ -0,0 +1,79 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Logging;
+
+/**
+ * Verwaltet die Log-Processors und wendet sie auf Log-Records an.
+ */
+final readonly class ProcessorManager
+{
+    /** @var array<LogProcessor> Liste der Processors, sortiert nach Priorität  */
+    private array $processors;
+
+    public function __construct(LogProcessor ...$processors)
+    {
+        $this->processors = $processors;
+    }
+
+    public function addProcessor(LogProcessor $processor): self
+    {
+        $processors = $this->sortProcessors($processor, ...$this->processors);
+
+        return new self(...$processors);
+    }
+
+    /**
+     * Wendet alle Processors auf einen Log-Record an
+     */
+    public function processRecord(LogRecord $record): LogRecord
+    {
+        foreach ($this->processors as $processor) {
+            $record = $processor->processRecord($record);
+        }
+
+        return $record;
+    }
+
+    /**
+     * Sortiert die Processors nach Priorität (höhere Priorität = frühere Ausführung)
+     */
+    private function sortProcessors(): array
+    {
+        $processors = $this->processors;
+
+        usort($processors, function (LogProcessor $a, LogProcessor $b) {
+            return $b->getPriority() <=> $a->getPriority(); // Absteigend sortieren
+        });
+
+        return $processors;
+    }
+
+    /**
+     * Gibt alle registrierten Processors zurück
+     *
+     * @return array<string, int> Array mit Processor-Namen als Schlüssel und Prioritäten als Werte
+     */
+    public function getProcessorList(): array
+    {
+        $result = [];
+
+        foreach ($this->processors as $processor) {
+            $result[$processor->getName()] = $processor->getPriority();
+        }
+
+        return $result;
+    }
+
+    public function hasProcessor(string $name): bool
+    {
+        return array_any($this->processors, fn($processor) => $processor->getName() === $name);
+
+    }
+
+    public function getProcessor(string $name): ?LogProcessor
+    {
+        return array_find($this->processors, fn($processor) => $processor->getName() === $name);
+
+    }
+}
diff --git a/src/Framework/Logging/Processors/ExceptionProcessor.php b/src/Framework/Logging/Processors/ExceptionProcessor.php
new file mode 100644
index 00000000..4717d8b4
--- /dev/null
+++ b/src/Framework/Logging/Processors/ExceptionProcessor.php
@@ -0,0 +1,132 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Logging\Processors;
+
+use App\Framework\Logging\LogProcessor;
+use App\Framework\Logging\LogRecord;
+
+/**
+ * Verarbeitet Exceptions im Kontext und fügt detaillierte Informationen hinzu.
+ */
+final class ExceptionProcessor implements LogProcessor
+{
+    /**
+     * @var int Priorität des Processors (15 = früh, nach Interpolation)
+     */
+    private const int PRIORITY = 15;
+
+    /**
+     * @var bool Ob Stack-Traces hinzugefügt werden sollen
+     */
+    private bool $includeStackTraces;
+
+    /**
+     * @var int Maximale Tiefe für Stack-Traces
+     */
+    private int $traceDepth;
+
+    /**
+     * Erstellt einen neuen ExceptionProcessor
+     */
+    public function __construct(
+        bool $includeStackTraces = true,
+        int $traceDepth = 10
+    ) {
+        $this->includeStackTraces = $includeStackTraces;
+        $this->traceDepth = $traceDepth;
+    }
+
+    /**
+     * Verarbeitet einen Log-Record und extrahiert Exception-Informationen
+     */
+    public function processRecord(LogRecord $record): LogRecord
+    {
+        $context = $record->getContext();
+
+        // Prüfen, ob eine Exception im Kontext vorhanden ist
+        if (isset($context['exception']) && $context['exception'] instanceof \Throwable) {
+            $exception = $context['exception'];
+            $exceptionData = $this->formatException($exception);
+
+            // Exception-Daten zu Extra-Daten hinzufügen
+            $record->addExtra('exception', $exceptionData);
+        }
+
+        return $record;
+    }
+
+    /**
+     * Formatiert eine Exception für das Logging
+     */
+    private function formatException(\Throwable $exception): array
+    {
+        $result = [
+            'class' => get_class($exception),
+            'message' => $exception->getMessage(),
+            'code' => $exception->getCode(),
+            'file' => $exception->getFile(),
+            'line' => $exception->getLine(),
+        ];
+
+        // Stack-Trace hinzufügen, wenn aktiviert
+        if ($this->includeStackTraces) {
+            $result['trace'] = $this->formatTrace($exception);
+        }
+
+        // Bei verschachtelten Exceptions auch die vorherige Exception formatieren
+        if ($exception->getPrevious()) {
+            $result['previous'] = $this->formatException($exception->getPrevious());
+        }
+
+        return $result;
+    }
+
+    /**
+     * Formatiert den Stack-Trace einer Exception
+     */
+    private function formatTrace(\Throwable $exception): array
+    {
+        $trace = $exception->getTrace();
+        $result = [];
+
+        // Tiefe begrenzen
+        $trace = array_slice($trace, 0, $this->traceDepth);
+
+        foreach ($trace as $frame) {
+            $entry = [
+                'file' => $frame['file'] ?? 'unknown',
+                'line' => $frame['line'] ?? 0,
+            ];
+
+            if (isset($frame['function'])) {
+                $function = '';
+                if (isset($frame['class'])) {
+                    $function .= $frame['class'] . $frame['type'];
+                }
+                $function .= $frame['function'];
+                $entry['function'] = $function;
+            }
+
+            $result[] = $entry;
+        }
+
+        return $result;
+    }
+
+    /**
+     * Gibt die Priorität des Processors zurück
+     */
+    public function getPriority(): int
+    {
+        return self::PRIORITY;
+    }
+
+    /**
+     * Gibt einen eindeutigen Namen für den Processor zurück
+     */
+    public function getName(): string
+    {
+        return 'exception';
+    }
+}
diff --git a/src/Framework/Logging/Processors/InterpolationProcessor.php b/src/Framework/Logging/Processors/InterpolationProcessor.php
new file mode 100644
index 00000000..0235007b
--- /dev/null
+++ b/src/Framework/Logging/Processors/InterpolationProcessor.php
@@ -0,0 +1,77 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Logging\Processors;
+
+use App\Framework\Logging\LogProcessor;
+use App\Framework\Logging\LogRecord;
+
+/**
+ * Ersetzt Platzhalter in Log-Nachrichten durch Kontext-Werte.
+ */
+final class InterpolationProcessor implements LogProcessor
+{
+    /**
+     * @var int Priorität des Processors (höher = früher, 20 = sehr früh)
+     */
+    private const int PRIORITY = 20;
+
+    /**
+     * Verarbeitet einen Log-Record und ersetzt Platzhalter in der Nachricht
+     */
+    public function processRecord(LogRecord $record): LogRecord
+    {
+        $message = $record->getMessage();
+        $context = $record->getContext();
+
+        // Platzhalter ersetzen, falls vorhanden
+        if (str_contains($message, '{')) {
+            $message = $this->interpolate($message, $context);
+            $record->setMessage($message);
+        }
+
+        return $record;
+    }
+
+    /**
+     * Platzhalter im Log-Text ersetzen
+     */
+    private function interpolate(string $message, array $context): string
+    {
+        // Platzhalter ersetzen (Format: {key})
+        $replace = [];
+
+        foreach ($context as $key => $val) {
+            if ($val === null || is_scalar($val) || (is_object($val) && method_exists($val, '__toString'))) {
+                $replace['{' . $key . '}'] = $val;
+            } elseif ($val instanceof \Throwable) {
+                $replace['{' . $key . '}'] = $val->getMessage() . ' in ' . $val->getFile() . ':' . $val->getLine();
+            } elseif (is_object($val)) {
+                $replace['{' . $key . '}'] = '[object ' . get_class($val) . ']';
+            } elseif (is_array($val)) {
+                $replace['{' . $key . '}'] = 'array' . json_encode($val,
+                    JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES | JSON_PARTIAL_OUTPUT_ON_ERROR);
+            } else {
+                $replace['{' . $key . '}'] = '[' . gettype($val) . ']';
+            }
+        }
+
+        return strtr($message, $replace);
+    }
+
+    /**
+     * Gibt die Priorität des Processors zurück
+     */
+    public function getPriority(): int
+    {
+        return self::PRIORITY;
+    }
+
+    /**
+     * Gibt einen eindeutigen Namen für den Processor zurück
+     */
+    public function getName(): string
+    {
+        return 'interpolation';
+    }
+}
diff --git a/src/Framework/Logging/Processors/IntrospectionProcessor.php b/src/Framework/Logging/Processors/IntrospectionProcessor.php
new file mode 100644
index 00000000..e46ef2af
--- /dev/null
+++ b/src/Framework/Logging/Processors/IntrospectionProcessor.php
@@ -0,0 +1,100 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Logging\Processors;
+
+use App\Framework\Logging\LogProcessor;
+use App\Framework\Logging\LogRecord;
+
+/**
+ * Fügt Code-Ortsinformationen (Datei, Zeile, Funktion) zu Log-Einträgen hinzu.
+ */
+final class IntrospectionProcessor implements LogProcessor
+{
+    /**
+     * @var int Priorität des Processors
+     */
+    private const int PRIORITY = 7;
+
+    /**
+     * @var string[] Liste der Klassen, die bei der Introspection ignoriert werden sollen
+     */
+    private array $skipClassesPartials;
+
+    /**
+     * @var int Anzahl der Frames, die übersprungen werden sollen (Logger usw.)
+     */
+    private int $skipStackFrames;
+
+    /**
+     * Erstellt einen neuen IntrospectionProcessor
+     *
+     * @param string[] $skipClassesPartials Liste der Klassen, die ignoriert werden sollen
+     * @param int $skipStackFrames Anzahl der Stack-Frames, die übersprungen werden sollen
+     */
+    public function __construct(
+        array $skipClassesPartials = ['App\\Framework\\Logging\\'],
+        int $skipStackFrames = 0
+    ) {
+        $this->skipClassesPartials = $skipClassesPartials;
+        $this->skipStackFrames = $skipStackFrames;
+    }
+
+    /**
+     * Verarbeitet einen Log-Record und fügt Introspection-Daten hinzu
+     */
+    public function processRecord(LogRecord $record): LogRecord
+    {
+        $trace = debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS);
+
+        // Überspringe Stack-Frames, die zur Logger-Infrastruktur gehören
+        $i = $this->skipStackFrames;
+        $framesCount = count($trace);
+
+        // Suche nach dem ersten Frame, der nicht zu ignorieren ist
+        while ($i < $framesCount) {
+            if (isset($trace[$i]['class'])) {
+                foreach ($this->skipClassesPartials as $partial) {
+                    if (str_starts_with($trace[$i]['class'], $partial)) {
+                        $i++;
+                        continue 2; // Zum nächsten Frame wechseln
+                    }
+                }
+            }
+            break; // Frame gefunden, der nicht ignoriert werden soll
+        }
+
+        // Sicherstellen, dass wir einen gültigen Frame haben
+        if ($i >= $framesCount) {
+            return $record; // Kein passender Frame gefunden
+        }
+
+        // Introspection-Daten extrahieren
+        $frame = $trace[$i];
+        $introspection = [
+            'file' => $frame['file'] ?? 'unknown',
+            'line' => $frame['line'] ?? 0,
+            'class' => $frame['class'] ?? '',
+            'function' => $frame['function'] ?? '',
+        ];
+
+        // Zu den Extra-Daten hinzufügen
+        return $record->addExtra('introspection', $introspection);
+    }
+
+    /**
+     * Gibt die Priorität des Processors zurück
+     */
+    public function getPriority(): int
+    {
+        return self::PRIORITY;
+    }
+
+    /**
+     * Gibt einen eindeutigen Namen für den Processor zurück
+     */
+    public function getName(): string
+    {
+        return 'introspection';
+    }
+}
diff --git a/src/Framework/Logging/Processors/RequestIdProcessor.php b/src/Framework/Logging/Processors/RequestIdProcessor.php
new file mode 100644
index 00000000..df43a06c
--- /dev/null
+++ b/src/Framework/Logging/Processors/RequestIdProcessor.php
@@ -0,0 +1,54 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Logging\Processors;
+
+use App\Framework\Http\RequestIdGenerator;
+use App\Framework\Logging\LogProcessor;
+use App\Framework\Logging\LogRecord;
+
+/**
+ * Fügt die Request-ID zu Log-Einträgen hinzu.
+ */
+final readonly class RequestIdProcessor implements LogProcessor
+{
+    /**
+     * @var int Priorität des Processors (10 = recht früh)
+     */
+    private const int PRIORITY = 10;
+
+    public function __construct(
+        private RequestIdGenerator $requestIdGenerator
+    ) {}
+
+    /**
+     * Verarbeitet einen Log-Record und fügt die Request-ID hinzu
+     */
+    public function processRecord(LogRecord $record): LogRecord
+    {
+        $currentId = $this->requestIdGenerator->getCurrentId();
+
+        if ($currentId !== null) {
+            // Nur die ID ohne Signatur als Extra-Feld hinzufügen
+            return $record->addExtra('request_id', $currentId->getId());
+        }
+
+        return $record;
+    }
+
+    /**
+     * Gibt die Priorität des Processors zurück
+     */
+    public function getPriority(): int
+    {
+        return self::PRIORITY;
+    }
+
+    /**
+     * Gibt einen eindeutigen Namen für den Processor zurück
+     */
+    public function getName(): string
+    {
+        return 'request_id';
+    }
+}
diff --git a/src/Framework/Logging/Processors/WebInfoProcessor.php b/src/Framework/Logging/Processors/WebInfoProcessor.php
new file mode 100644
index 00000000..f5db6e69
--- /dev/null
+++ b/src/Framework/Logging/Processors/WebInfoProcessor.php
@@ -0,0 +1,146 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Logging\Processors;
+
+use App\Framework\Logging\LogProcessor;
+use App\Framework\Logging\LogRecord;
+
+/**
+ * Fügt Web-Informationen wie IP, URL, Methode und User-Agent zu Log-Einträgen hinzu.
+ */
+final class WebInfoProcessor implements LogProcessor
+{
+    /**
+     * @var int Priorität des Processors (5 = früh, aber nach Request-ID)
+     */
+    private const int PRIORITY = 5;
+
+    /**
+     * @var array Konfiguration, welche Informationen gesammelt werden sollen
+     */
+    private array $config;
+
+    /**
+     * Erstellt einen neuen WebInfoProcessor
+     *
+     * @param array $config Konfiguration, welche Informationen gesammelt werden sollen
+     */
+    public function __construct(array $config = [])
+    {
+        $this->config = array_merge(
+            [
+                'url' => true,
+                'ip' => true,
+                'http_method' => true,
+                'user_agent' => true,
+                'referrer' => false,
+            ],
+            $config
+        );
+    }
+
+    /**
+     * Verarbeitet einen Log-Record und fügt Web-Informationen hinzu
+     */
+    public function processRecord(LogRecord $record): LogRecord
+    {
+        // Nur im Web-Kontext ausführen
+        if (PHP_SAPI === 'cli') {
+            return $record;
+        }
+
+        // Webinfos als Extra-Felder hinzufügen
+        $extras = $this->collectWebInfo();
+        if (!empty($extras)) {
+            $record->addExtras($extras);
+        }
+
+        return $record;
+    }
+
+    /**
+     * Sammelt Informationen aus dem Web-Kontext
+     */
+    private function collectWebInfo(): array
+    {
+        $info = [];
+
+        if ($this->config['url'] && isset($_SERVER['REQUEST_URI'])) {
+            $info['url'] = $this->getFullUrl();
+        }
+
+        if ($this->config['ip'] && isset($_SERVER['REMOTE_ADDR'])) {
+            $info['ip'] = $this->getClientIp();
+        }
+
+        if ($this->config['http_method'] && isset($_SERVER['REQUEST_METHOD'])) {
+            $info['http_method'] = $_SERVER['REQUEST_METHOD'];
+        }
+
+        if ($this->config['user_agent'] && isset($_SERVER['HTTP_USER_AGENT'])) {
+            $info['user_agent'] = $_SERVER['HTTP_USER_AGENT'];
+        }
+
+        if ($this->config['referrer'] && isset($_SERVER['HTTP_REFERER'])) {
+            $info['referrer'] = $_SERVER['HTTP_REFERER'];
+        }
+
+        return $info;
+    }
+
+    /**
+     * Ermittelt die vollständige URL des Requests
+     */
+    private function getFullUrl(): string
+    {
+        $protocol = (!empty($_SERVER['HTTPS']) && $_SERVER['HTTPS'] !== 'off') ? 'https' : 'http';
+        $host = $_SERVER['HTTP_HOST'] ?? $_SERVER['SERVER_NAME'] ?? 'localhost';
+        $uri = $_SERVER['REQUEST_URI'] ?? '/';
+
+        return $protocol . '://' . $host . $uri;
+    }
+
+    /**
+     * Ermittelt die IP-Adresse des Clients unter Berücksichtigung von Proxies
+     */
+    private function getClientIp(): string
+    {
+        $keys = [
+            'HTTP_CF_CONNECTING_IP', // Cloudflare
+            'HTTP_X_FORWARDED_FOR',  // Standard Proxy/Load Balancer
+            'HTTP_CLIENT_IP',        // Manche Proxies
+            'REMOTE_ADDR',           // Fallback direkte Verbindung
+        ];
+
+        foreach ($keys as $key) {
+            if (isset($_SERVER[$key])) {
+                // Bei X-Forwarded-For kann eine Komma-separierte Liste vorliegen
+                if ($key === 'HTTP_X_FORWARDED_FOR') {
+                    $ips = explode(',', $_SERVER[$key]);
+                    return trim($ips[0]); // Erste IP = ursprünglicher Client
+                }
+
+                return $_SERVER[$key];
+            }
+        }
+
+        return 'unknown';
+    }
+
+    /**
+     * Gibt die Priorität des Processors zurück
+     */
+    public function getPriority(): int
+    {
+        return self::PRIORITY;
+    }
+
+    /**
+     * Gibt einen eindeutigen Namen für den Processor zurück
+     */
+    public function getName(): string
+    {
+        return 'web_info';
+    }
+}
diff --git a/src/Framework/Markdown/MarkdownConverter.php b/src/Framework/Markdown/MarkdownConverter.php
new file mode 100644
index 00000000..dc7c9d80
--- /dev/null
+++ b/src/Framework/Markdown/MarkdownConverter.php
@@ -0,0 +1,62 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Markdown;
+
+final readonly class MarkdownConverter
+{
+    public function toHtml(string $markdown): string
+    {
+        // Einfacher Markdown-zu-HTML Converter
+        $html = $markdown;
+
+        // Headers
+        $html = preg_replace('/^# (.+)$/m', '<h1>$1</h1>', $html);
+        $html = preg_replace('/^## (.+)$/m', '<h2>$1</h2>', $html);
+        $html = preg_replace('/^### (.+)$/m', '<h3>$1</h3>', $html);
+
+        // Bold und Italic
+        $html = preg_replace('/\*\*(.+?)\*\*/', '<strong>$1</strong>', $html);
+        $html = preg_replace('/\*(.+?)\*/', '<em>$1</em>', $html);
+
+        // Code Blöcke
+        $html = preg_replace('/```(\w+)?\n(.*?)\n```/s', '<pre><code class="language-$1">$2</code></pre>', $html);
+        $html = preg_replace('/`(.+?)`/', '<code>$1</code>', $html);
+
+        // Links
+        $html = preg_replace('/\[(.+?)\]\((.+?)\)/', '<a href="$2">$1</a>', $html);
+
+        // Listen
+        $html = preg_replace('/^- (.+)$/m', '<li>$1</li>', $html);
+        $html = preg_replace('/(<li>.*<\/li>)/s', '<ul>$1</ul>', $html);
+
+        // Blockquotes
+        $html = preg_replace('/^> (.+)$/m', '<blockquote>$1</blockquote>', $html);
+
+        // Paragraphen
+        $html = preg_replace('/\n\n/', '</p><p>', $html);
+        $html = '<p>' . $html . '</p>';
+
+        // Zeilenumbrüche
+        $html = preg_replace('/\n/', '<br>', $html);
+
+        return $html;
+    }
+
+    public function stripMarkdown(string $markdown): string
+    {
+        $text = $markdown;
+
+        // Entferne Markdown-Syntax
+        $text = preg_replace('/^#+\s/', '', $text); // Headers
+        $text = preg_replace('/\*\*(.+?)\*\*/', '$1', $text); // Bold
+        $text = preg_replace('/\*(.+?)\*/', '$1', $text); // Italic
+        $text = preg_replace('/```.*?\n(.*?)\n```/s', '$1', $text); // Code Blöcke
+        $text = preg_replace('/`(.+?)`/', '$1', $text); // Inline Code
+        $text = preg_replace('/\[(.+?)\]\((.+?)\)/', '$1 ($2)', $text); // Links
+        $text = preg_replace('/^[\-\*] /', '', $text); // Listen
+        $text = preg_replace('/^> /', '', $text); // Blockquotes
+
+        return trim($text);
+    }
+}
diff --git a/src/Framework/Meta/Keywords.php b/src/Framework/Meta/Keywords.php
new file mode 100644
index 00000000..cfd465a1
--- /dev/null
+++ b/src/Framework/Meta/Keywords.php
@@ -0,0 +1,16 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Meta;
+
+final class Keywords
+{
+    private function __construct(
+        public array $keywords,
+    ) {}
+
+    public static function fromStrings(string ...$keywords): self
+    {
+        return new self($keywords);
+    }
+}
diff --git a/src/Framework/Meta/MetaData.php b/src/Framework/Meta/MetaData.php
new file mode 100644
index 00000000..46879ec6
--- /dev/null
+++ b/src/Framework/Meta/MetaData.php
@@ -0,0 +1,13 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Meta;
+
+final readonly class MetaData
+{
+    public function __construct(
+        public string $title,
+        public string $description = '',
+        public OpenGraph $openGraph = new OpenGraphTypeWebsite,
+    ) {}
+}
diff --git a/src/Framework/Meta/MetaResolver.php b/src/Framework/Meta/MetaResolver.php
new file mode 100644
index 00000000..e0fd292b
--- /dev/null
+++ b/src/Framework/Meta/MetaResolver.php
@@ -0,0 +1,8 @@
+<?php
+
+namespace App\Framework\Meta;
+
+interface MetaResolver
+{
+    public function __invoke(): MetaData;
+}
diff --git a/src/Framework/Meta/OpenGraph.php b/src/Framework/Meta/OpenGraph.php
new file mode 100644
index 00000000..f2a27be2
--- /dev/null
+++ b/src/Framework/Meta/OpenGraph.php
@@ -0,0 +1,8 @@
+<?php
+
+namespace App\Framework\Meta;
+
+interface OpenGraph
+{
+    public OpenGraphType $type {get;}
+}
diff --git a/src/Framework/Meta/OpenGraphType.php b/src/Framework/Meta/OpenGraphType.php
new file mode 100644
index 00000000..d8159f85
--- /dev/null
+++ b/src/Framework/Meta/OpenGraphType.php
@@ -0,0 +1,10 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Meta;
+
+enum OpenGraphType:string
+{
+    case WEBSITE = 'website';
+    case ARTICLE = 'article';
+}
diff --git a/src/Framework/Meta/OpenGraphTypeWebsite.php b/src/Framework/Meta/OpenGraphTypeWebsite.php
new file mode 100644
index 00000000..6b935a4c
--- /dev/null
+++ b/src/Framework/Meta/OpenGraphTypeWebsite.php
@@ -0,0 +1,9 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Meta;
+
+final class OpenGraphTypeWebsite implements OpenGraph
+{
+    public OpenGraphType $type = OpenGraphType::WEBSITE;
+}
diff --git a/src/Framework/Meta/StaticPageMetaResolver.php b/src/Framework/Meta/StaticPageMetaResolver.php
new file mode 100644
index 00000000..5483ceea
--- /dev/null
+++ b/src/Framework/Meta/StaticPageMetaResolver.php
@@ -0,0 +1,23 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Meta;
+
+final class StaticPageMetaResolver implements MetaResolver
+{
+    public function __construct(
+        public string $title,
+        public string $description,
+        #public Keywords $keywords,
+    ) {}
+
+    public function __invoke(): MetaData
+    {
+        return new MetaData(
+            $this->title,
+            $this->description,
+            #$this->keywords,
+            new OpenGraphTypeWebsite
+        );
+    }
+}
diff --git a/src/Framework/Performance/EventHandler/MeasureApplicationBootHandler.php b/src/Framework/Performance/EventHandler/MeasureApplicationBootHandler.php
new file mode 100644
index 00000000..d6619367
--- /dev/null
+++ b/src/Framework/Performance/EventHandler/MeasureApplicationBootHandler.php
@@ -0,0 +1,18 @@
+<?php
+
+namespace App\Framework\Performance\EventHandler;
+
+use App\Framework\Core\Events\ApplicationBooted;
+use App\Framework\Core\Events\OnEvent;
+use App\Framework\Performance\PerformanceMeter;
+
+final readonly class MeasureApplicationBootHandler
+{
+    public function __construct(private PerformanceMeter $meter) {}
+
+    #[OnEvent]
+    public function onApplicationBooted(ApplicationBooted $event): void
+    {
+        $this->meter->mark('application:booted');
+    }
+}
diff --git a/src/Framework/Performance/Examples/DatabasePerformanceExample.php b/src/Framework/Performance/Examples/DatabasePerformanceExample.php
new file mode 100644
index 00000000..8586ad81
--- /dev/null
+++ b/src/Framework/Performance/Examples/DatabasePerformanceExample.php
@@ -0,0 +1,455 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Performance\Examples;
+
+use App\Framework\Performance\PerformanceMeter;
+use App\Framework\Performance\PerformanceCategory;
+
+/**
+ * Beispiel für Database-Performance-Tracking
+ *
+ * Zeigt, wie Database-Operationen mit dem PerformanceMeter
+ * gemessen und analysiert werden können.
+ */
+class DatabasePerformanceExample
+{
+    private PerformanceMeter $meter;
+    private array $queryLog = [];
+    private array $config;
+
+    public function __construct(PerformanceMeter $meter, array $config = [])
+    {
+        $this->meter = $meter;
+        $this->config = array_merge([
+            'log_all_queries' => false,
+            'log_slow_queries_only' => true,
+            'slow_query_threshold_ms' => 100,
+            'track_query_patterns' => true,
+            'track_connection_pool' => true,
+        ], $config);
+    }
+
+    /**
+     * Query-Ausführung mit Performance-Tracking
+     */
+    public function executeQuery(string $sql, array $params = []): array
+    {
+        $queryId = uniqid('query_');
+        $queryType = $this->getQueryType($sql);
+        $measurementId = "db_query_{$queryType}_{$queryId}";
+
+        // Query-Start markieren
+        $this->meter->mark("query_start_{$queryType}", PerformanceCategory::DATABASE);
+
+        // Query-Kontext sammeln
+        $queryContext = [
+            'sql' => $sql,
+            'params' => $params,
+            'type' => $queryType,
+            'start_time' => microtime(true),
+        ];
+
+        $this->queryLog[$queryId] = $queryContext;
+
+        // Hauptmessung starten
+        $this->meter->startMeasure($measurementId, PerformanceCategory::DATABASE);
+
+        try {
+            // Query-Preparation messen
+            $statement = $this->meter->measure('query_preparation', function() use ($sql) {
+                return $this->prepareStatement($sql);
+            }, PerformanceCategory::DATABASE);
+
+            // Parameter-Binding messen
+            if (!empty($params)) {
+                $this->meter->measure('parameter_binding', function() use ($statement, $params) {
+                    $this->bindParameters($statement, $params);
+                }, PerformanceCategory::DATABASE);
+            }
+
+            // Query-Execution messen
+            $result = $this->meter->measure('query_execution', function() use ($statement) {
+                return $this->executeStatement($statement);
+            }, PerformanceCategory::DATABASE);
+
+            // Result-Fetching messen (bei SELECT)
+            if ($queryType === 'SELECT') {
+                $data = $this->meter->measure('result_fetching', function() use ($result) {
+                    return $this->fetchResults($result);
+                }, PerformanceCategory::DATABASE);
+            } else {
+                $data = $result;
+            }
+
+            // Query-Ende markieren
+            $this->meter->mark("query_end_{$queryType}", PerformanceCategory::DATABASE);
+
+            // Performance-Analyse
+            $this->analyzeQueryPerformance($queryId, $queryContext);
+
+            return $data;
+
+        } catch (\Exception $e) {
+            $this->meter->mark("query_error_{$queryType}", PerformanceCategory::DATABASE);
+            throw $e;
+        } finally {
+            $this->meter->endMeasure($measurementId);
+            unset($this->queryLog[$queryId]);
+        }
+    }
+
+    /**
+     * Transaction-Performance-Tracking
+     */
+    public function executeTransaction(callable $operations): mixed
+    {
+        $transactionId = uniqid('trans_');
+        $measurementId = "db_transaction_{$transactionId}";
+
+        $this->meter->mark('transaction_begin', PerformanceCategory::DATABASE);
+        $this->meter->startMeasure($measurementId, PerformanceCategory::DATABASE);
+
+        // Transaction-Start messen
+        $this->meter->measure('transaction_start', function() {
+            $this->beginTransaction();
+        }, PerformanceCategory::DATABASE);
+
+        try {
+            // Transaction-Operationen ausführen
+            $result = $this->meter->measure('transaction_operations', function() use ($operations) {
+                return $operations();
+            }, PerformanceCategory::DATABASE);
+
+            // Commit messen
+            $this->meter->measure('transaction_commit', function() {
+                $this->commitTransaction();
+            }, PerformanceCategory::DATABASE);
+
+            $this->meter->mark('transaction_committed', PerformanceCategory::DATABASE);
+
+            return $result;
+
+        } catch (\Exception $e) {
+            // Rollback messen
+            $this->meter->measure('transaction_rollback', function() {
+                $this->rollbackTransaction();
+            }, PerformanceCategory::DATABASE);
+
+            $this->meter->mark('transaction_rolled_back', PerformanceCategory::DATABASE);
+            throw $e;
+
+        } finally {
+            $this->meter->endMeasure($measurementId);
+        }
+    }
+
+    /**
+     * Bulk-Insert mit Performance-Tracking
+     */
+    public function bulkInsert(string $table, array $data): bool
+    {
+        $recordCount = count($data);
+        $measurementId = "bulk_insert_{$table}_{$recordCount}";
+
+        $this->meter->mark("bulk_insert_start_{$table}", PerformanceCategory::DATABASE);
+        $this->meter->startMeasure($measurementId, PerformanceCategory::DATABASE);
+
+        try {
+            // Data-Preparation
+            $preparedData = $this->meter->measure('bulk_data_preparation', function() use ($data) {
+                return $this->prepareBulkData($data);
+            }, PerformanceCategory::DATABASE);
+
+            // SQL-Generation
+            $sql = $this->meter->measure('bulk_sql_generation', function() use ($table, $preparedData) {
+                return $this->generateBulkInsertSql($table, $preparedData);
+            }, PerformanceCategory::DATABASE);
+
+            // Bulk-Execution
+            $result = $this->meter->measure('bulk_execution', function() use ($sql, $preparedData) {
+                return $this->executeBulkInsert($sql, $preparedData);
+            }, PerformanceCategory::DATABASE);
+
+            $this->meter->mark("bulk_insert_completed_{$table}", PerformanceCategory::DATABASE);
+
+            // Performance-Statistiken
+            $this->logBulkInsertStats($table, $recordCount);
+
+            return $result;
+
+        } finally {
+            $this->meter->endMeasure($measurementId);
+        }
+    }
+
+    /**
+     * Connection-Pool Performance-Tracking
+     */
+    public function withConnection(callable $operation): mixed
+    {
+        if (!$this->config['track_connection_pool']) {
+            return $operation();
+        }
+
+        $connectionId = uniqid('conn_');
+
+        // Connection-Acquisition messen
+        $connection = $this->meter->measure('connection_acquisition', function() {
+            return $this->acquireConnection();
+        }, PerformanceCategory::DATABASE);
+
+        $this->meter->mark('connection_acquired', PerformanceCategory::DATABASE);
+
+        try {
+            // Operation ausführen
+            return $this->meter->measure("connection_operation_{$connectionId}", function() use ($operation, $connection) {
+                return $operation($connection);
+            }, PerformanceCategory::DATABASE);
+
+        } finally {
+            // Connection-Release messen
+            $this->meter->measure('connection_release', function() use ($connection) {
+                $this->releaseConnection($connection);
+            }, PerformanceCategory::DATABASE);
+
+            $this->meter->mark('connection_released', PerformanceCategory::DATABASE);
+        }
+    }
+
+    /**
+     * Query-Performance analysieren
+     */
+    private function analyzeQueryPerformance(string $queryId, array $context): void
+    {
+        $duration = (microtime(true) - $context['start_time']) * 1000;
+        $queryType = $context['type'];
+
+        // Slow-Query Detection
+        if ($duration > $this->config['slow_query_threshold_ms']) {
+            $this->meter->mark("slow_query_{$queryType}", PerformanceCategory::DATABASE);
+            $this->handleSlowQuery($context, $duration);
+        }
+
+        // Query-Pattern-Tracking
+        if ($this->config['track_query_patterns']) {
+            $this->trackQueryPattern($context, $duration);
+        }
+
+        // Logging-Entscheidung
+        $shouldLog = $this->config['log_all_queries'] ||
+                    ($this->config['log_slow_queries_only'] && $duration > $this->config['slow_query_threshold_ms']);
+
+        if ($shouldLog) {
+            $this->logQueryPerformance($context, $duration);
+        }
+    }
+
+    /**
+     * Langsame Queries behandeln
+     */
+    private function handleSlowQuery(array $context, float $duration): void
+    {
+        error_log("SLOW QUERY DETECTED: {$context['type']} took {$duration}ms");
+        error_log("SQL: " . $this->sanitizeSqlForLogging($context['sql']));
+
+        // Detailed Performance-Report für slow queries
+        $report = $this->meter->generateReport();
+        $dbMeasurements = array_filter($report['measurements'], function($m) {
+            return $m['category'] === 'database';
+        });
+
+        if (!empty($dbMeasurements)) {
+            error_log("DB Performance breakdown: " . json_encode($dbMeasurements));
+        }
+    }
+
+    /**
+     * Query-Pattern-Tracking
+     */
+    private function trackQueryPattern(array $context, float $duration): void
+    {
+        $pattern = $this->extractQueryPattern($context['sql']);
+        $patternMeasurement = "query_pattern_{$pattern}";
+
+        // Pattern-spezifische Statistiken in separater Messung
+        static $patternMeasurements = [];
+
+        if (!isset($patternMeasurements[$pattern])) {
+            $patternMeasurements[$pattern] = [
+                'count' => 0,
+                'total_time' => 0,
+                'measurement_id' => $patternMeasurement,
+            ];
+        }
+
+        $patternMeasurements[$pattern]['count']++;
+        $patternMeasurements[$pattern]['total_time'] += $duration;
+
+        // Bei häufigen Patterns: Marker setzen
+        if ($patternMeasurements[$pattern]['count'] % 10 === 0) {
+            $avgTime = $patternMeasurements[$pattern]['total_time'] / $patternMeasurements[$pattern]['count'];
+            $this->meter->mark("frequent_pattern_{$pattern}_avg_{$avgTime}ms", PerformanceCategory::DATABASE);
+        }
+    }
+
+    /**
+     * Bulk-Insert-Statistiken loggen
+     */
+    private function logBulkInsertStats(string $table, int $recordCount): void
+    {
+        $report = $this->meter->generateReport();
+
+        // Bulk-Insert-spezifische Messungen finden
+        $bulkMeasurements = array_filter($report['measurements'], function($m) {
+            return strpos($m['category'], 'bulk') !== false ||
+                   strpos($m['category'], 'database') !== false;
+        });
+
+        $totalTime = array_sum(array_column($bulkMeasurements, 'total_time_ms'));
+        $recordsPerSecond = $recordCount / ($totalTime / 1000);
+
+        error_log("BULK INSERT STATS: {$table} - {$recordCount} records in {$totalTime}ms ({$recordsPerSecond} records/sec)");
+    }
+
+    /**
+     * Query-Performance loggen
+     */
+    private function logQueryPerformance(array $context, float $duration): void
+    {
+        $logData = [
+            'query_type' => $context['type'],
+            'duration_ms' => round($duration, 2),
+            'sql_pattern' => $this->extractQueryPattern($context['sql']),
+            'param_count' => count($context['params']),
+            'timestamp' => microtime(true),
+        ];
+
+        // Sensitive Parameter entfernen
+        if (!empty($context['params'])) {
+            $logData['has_params'] = true;
+        }
+
+        error_log('DB_PERFORMANCE: ' . json_encode($logData));
+    }
+
+    // === HELPER-METHODEN ===
+
+    private function getQueryType(string $sql): string
+    {
+        $sql = trim(strtoupper($sql));
+
+        if (strpos($sql, 'SELECT') === 0) return 'SELECT';
+        if (strpos($sql, 'INSERT') === 0) return 'INSERT';
+        if (strpos($sql, 'UPDATE') === 0) return 'UPDATE';
+        if (strpos($sql, 'DELETE') === 0) return 'DELETE';
+        if (strpos($sql, 'CREATE') === 0) return 'CREATE';
+        if (strpos($sql, 'ALTER') === 0) return 'ALTER';
+        if (strpos($sql, 'DROP') === 0) return 'DROP';
+
+        return 'OTHER';
+    }
+
+    private function extractQueryPattern(string $sql): string
+    {
+        // SQL normalisieren für Pattern-Erkennung
+        $pattern = preg_replace('/\s+/', ' ', trim($sql));
+        $pattern = preg_replace('/\d+/', '?', $pattern); // Zahlen durch ? ersetzen
+        $pattern = preg_replace("/'[^']*'/", '?', $pattern); // Strings durch ? ersetzen
+        $pattern = preg_replace('/\([^)]*\)/', '(?)', $pattern); // Parameter-Listen normalisieren
+
+        return substr($pattern, 0, 100); // Auf 100 Zeichen kürzen
+    }
+
+    private function sanitizeSqlForLogging(string $sql): string
+    {
+        // Sensitive Daten für Logging entfernen
+        $sanitized = preg_replace("/'[^']*'/", "'***'", $sql);
+        return substr($sanitized, 0, 200) . (strlen($sanitized) > 200 ? '...' : '');
+    }
+
+    // === DUMMY-IMPLEMENTIERUNGEN ===
+
+    private function prepareStatement(string $sql): object
+    {
+        usleep(2000); // 2ms für Statement-Preparation
+        return (object)['sql' => $sql, 'prepared' => true];
+    }
+
+    private function bindParameters(object $statement, array $params): void
+    {
+        usleep(1000 * count($params)); // 1ms pro Parameter
+    }
+
+    private function executeStatement(object $statement): object
+    {
+        $queryType = $this->getQueryType($statement->sql);
+        $executionTimes = [
+            'SELECT' => rand(5000, 50000),   // 5-50ms
+            'INSERT' => rand(2000, 15000),   // 2-15ms
+            'UPDATE' => rand(3000, 25000),   // 3-25ms
+            'DELETE' => rand(3000, 20000),   // 3-20ms
+            'OTHER' => rand(1000, 10000),    // 1-10ms
+        ];
+
+        usleep($executionTimes[$queryType] ?? 5000);
+
+        return (object)[
+            'success' => true,
+            'affected_rows' => rand(1, 100),
+            'data' => range(1, rand(1, 1000)),
+        ];
+    }
+
+    private function fetchResults(object $result): array
+    {
+        $rowCount = count($result->data);
+        usleep(100 * $rowCount); // 0.1ms pro Row
+        return $result->data;
+    }
+
+    private function beginTransaction(): void
+    {
+        usleep(1000); // 1ms für Transaction-Start
+    }
+
+    private function commitTransaction(): void
+    {
+        usleep(3000); // 3ms für Commit
+    }
+
+    private function rollbackTransaction(): void
+    {
+        usleep(2000); // 2ms für Rollback
+    }
+
+    private function prepareBulkData(array $data): array
+    {
+        usleep(500 * count($data)); // 0.5ms pro Record
+        return $data;
+    }
+
+    private function generateBulkInsertSql(string $table, array $data): string
+    {
+        usleep(2000); // 2ms für SQL-Generation
+        return "INSERT INTO {$table} VALUES " . str_repeat('(?),', count($data));
+    }
+
+    private function executeBulkInsert(string $sql, array $data): bool
+    {
+        usleep(1000 * count($data)); // 1ms pro Record
+        return true;
+    }
+
+    private function acquireConnection(): object
+    {
+        usleep(rand(1000, 10000)); // 1-10ms für Connection-Akquisition
+        return (object)['id' => uniqid('conn_'), 'acquired_at' => microtime(true)];
+    }
+
+    private function releaseConnection(object $connection): void
+    {
+        usleep(500); // 0.5ms für Connection-Release
+    }
+}
diff --git a/src/Framework/Performance/Examples/PerformanceEventHandlerExample.php b/src/Framework/Performance/Examples/PerformanceEventHandlerExample.php
new file mode 100644
index 00000000..07786ec7
--- /dev/null
+++ b/src/Framework/Performance/Examples/PerformanceEventHandlerExample.php
@@ -0,0 +1,538 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Performance\Examples;
+
+use App\Framework\Performance\PerformanceMeter;
+use App\Framework\Performance\PerformanceCategory;
+
+/**
+ * Beispiel-Event-Handler für Event-Performance-Tracking
+ *
+ * Dieser Handler zeigt, wie Performance-Messungen bei verschiedenen
+ * Event-Typen implementiert werden können.
+ */
+class PerformanceEventHandlerExample
+{
+    private PerformanceMeter $meter;
+    private array $activeEventMeasurements = [];
+    private array $eventStatistics = [];
+    private array $config;
+
+    public function __construct(PerformanceMeter $meter, array $config = [])
+    {
+        $this->meter = $meter;
+        $this->config = array_merge([
+            'track_all_events' => true,
+            'track_slow_events_only' => false,
+            'slow_event_threshold_ms' => 100,
+            'detailed_sub_measurements' => true,
+            'enable_event_statistics' => true,
+        ], $config);
+    }
+
+    /**
+     * Event-Start-Handler - beginnt Performance-Tracking
+     */
+    public function onEventStart($event): void
+    {
+        $eventName = $this->getEventName($event);
+        $eventId = $this->getEventId($event);
+        $measurementId = "event_{$eventName}_{$eventId}";
+
+        // Event-Start markieren
+        $this->meter->mark("event_start_{$eventName}", PerformanceCategory::EVENT);
+
+        // Hauptmessung für das Event starten
+        $this->meter->startMeasure($measurementId, PerformanceCategory::EVENT);
+
+        // Für spätere Referenz speichern
+        $this->activeEventMeasurements[$eventId] = [
+            'measurement_id' => $measurementId,
+            'event_name' => $eventName,
+            'start_time' => microtime(true),
+            'start_memory' => memory_get_usage(true),
+        ];
+
+        // Event-spezifische Performance-Messungen
+        $this->trackEventSpecificMetrics($event, $eventName);
+    }
+
+    /**
+     * Event-Ende-Handler - beendet Performance-Tracking
+     */
+    public function onEventEnd($event): void
+    {
+        $eventId = $this->getEventId($event);
+
+        if (!isset($this->activeEventMeasurements[$eventId])) {
+            return; // Event wurde nicht getrackt
+        }
+
+        $measurement = $this->activeEventMeasurements[$eventId];
+        $eventName = $measurement['event_name'];
+        $measurementId = $measurement['measurement_id'];
+
+        // Hauptmessung beenden
+        $this->meter->endMeasure($measurementId);
+
+        // Event-Ende markieren
+        $this->meter->mark("event_end_{$eventName}", PerformanceCategory::EVENT);
+
+        // Performance-Analyse
+        $duration = (microtime(true) - $measurement['start_time']) * 1000;
+        $memoryUsed = (memory_get_usage(true) - $measurement['start_memory']) / 1024 / 1024;
+
+        // Statistiken aktualisieren
+        if ($this->config['enable_event_statistics']) {
+            $this->updateEventStatistics($eventName, $duration, $memoryUsed);
+        }
+
+        // Langsame Events kennzeichnen
+        if ($duration > $this->config['slow_event_threshold_ms']) {
+            $this->meter->mark("slow_event_{$eventName}", PerformanceCategory::EVENT);
+            $this->handleSlowEvent($event, $duration);
+        }
+
+        // Performance-Daten ausgeben/loggen
+        $this->logEventPerformance($event, $duration, $memoryUsed);
+
+        // Cleanup
+        unset($this->activeEventMeasurements[$eventId]);
+    }
+
+    /**
+     * Spezifische Event-Handler mit detaillierten Messungen
+     */
+    public function handleUserRegistrationEvent($event): void
+    {
+        $this->meter->startMeasure('user_registration_processing', PerformanceCategory::USER);
+
+        // Email-Validierung messen
+        $this->meter->measure('email_validation', function() use ($event) {
+            $this->validateUserEmail($event->getEmail());
+        }, PerformanceCategory::VALIDATION);
+
+        // Password-Hashing messen
+        $this->meter->measure('password_hashing', function() use ($event) {
+            $this->hashUserPassword($event->getPassword());
+        }, PerformanceCategory::SECURITY);
+
+        // Database-Insert messen
+        $this->meter->measure('user_db_insert', function() use ($event) {
+            $this->insertUserToDatabase($event->getUserData());
+        }, PerformanceCategory::DATABASE);
+
+        // Welcome-Email senden (async)
+        $this->meter->measure('welcome_email_queue', function() use ($event) {
+            $this->queueWelcomeEmail($event->getUser());
+        }, PerformanceCategory::EXTERNAL);
+
+        $this->meter->endMeasure('user_registration_processing');
+
+        // Zusätzliche Marker für wichtige Schritte
+        $this->meter->mark('user_registered', PerformanceCategory::USER);
+    }
+
+    /**
+     * E-Commerce Order Event Handler
+     */
+    public function handleOrderCreatedEvent($event): void
+    {
+        $this->meter->startMeasure('order_processing', PerformanceCategory::BUSINESS);
+
+        // Inventory-Check
+        $this->meter->measure('inventory_check', function() use ($event) {
+            $this->checkOrderInventory($event->getOrderItems());
+        }, PerformanceCategory::DATABASE);
+
+        // Payment-Processing
+        $this->meter->measure('payment_processing', function() use ($event) {
+            $this->processOrderPayment($event->getPaymentData());
+        }, PerformanceCategory::EXTERNAL);
+
+        // Tax-Calculation
+        $this->meter->measure('tax_calculation', function() use ($event) {
+            $this->calculateOrderTax($event->getOrder());
+        }, PerformanceCategory::BUSINESS);
+
+        // Order-Confirmation
+        $this->meter->measure('order_confirmation', function() use ($event) {
+            $this->sendOrderConfirmation($event->getOrder());
+        }, PerformanceCategory::EXTERNAL);
+
+        // Inventory-Update
+        $this->meter->measure('inventory_update', function() use ($event) {
+            $this->updateInventoryAfterOrder($event->getOrderItems());
+        }, PerformanceCategory::DATABASE);
+
+        $this->meter->endMeasure('order_processing');
+
+        $this->meter->mark('order_completed', PerformanceCategory::BUSINESS);
+    }
+
+    /**
+     * File-Upload Event Handler
+     */
+    public function handleFileUploadEvent($event): void
+    {
+        $this->meter->startMeasure('file_upload_processing', PerformanceCategory::FILE);
+
+        $fileSize = $event->getFileSize();
+        $fileName = $event->getFileName();
+
+        // File-Validation
+        $this->meter->measure('file_validation', function() use ($event) {
+            $this->validateUploadedFile($event->getFile());
+        }, PerformanceCategory::VALIDATION);
+
+        // Virus-Scan (bei großen Files)
+        if ($fileSize > 1024 * 1024) { // > 1MB
+            $this->meter->measure('virus_scan', function() use ($event) {
+                $this->scanFileForViruses($event->getFile());
+            }, PerformanceCategory::SECURITY);
+        }
+
+        // File-Resize/Processing (bei Images)
+        if ($this->isImage($fileName)) {
+            $this->meter->measure('image_processing', function() use ($event) {
+                $this->processUploadedImage($event->getFile());
+            }, PerformanceCategory::FILE);
+        }
+
+        // File-Storage
+        $this->meter->measure('file_storage', function() use ($event) {
+            $this->storeFile($event->getFile(), $event->getStoragePath());
+        }, PerformanceCategory::FILE);
+
+        // Metadata-Extraction
+        $this->meter->measure('metadata_extraction', function() use ($event) {
+            $this->extractFileMetadata($event->getFile());
+        }, PerformanceCategory::FILE);
+
+        $this->meter->endMeasure('file_upload_processing');
+
+        // File-Size-spezifische Marker
+        if ($fileSize > 10 * 1024 * 1024) { // > 10MB
+            $this->meter->mark('large_file_uploaded', PerformanceCategory::FILE);
+        }
+    }
+
+    /**
+     * Cache-Event Handler
+     */
+    public function handleCacheEvent($event): void
+    {
+        $operation = $event->getOperation(); // 'get', 'set', 'delete', 'flush'
+        $cacheKey = $event->getCacheKey();
+
+        $measurementId = "cache_{$operation}_{$cacheKey}";
+
+        $result = $this->meter->measure($measurementId, function() use ($event) {
+            return $this->executeCacheOperation($event);
+        }, PerformanceCategory::CACHE);
+
+        // Cache-Hit/Miss markieren
+        if ($operation === 'get') {
+            $hitMiss = $result !== null ? 'hit' : 'miss';
+            $this->meter->mark("cache_{$hitMiss}_{$cacheKey}", PerformanceCategory::CACHE);
+        }
+
+        // Cache-Statistiken aktualisieren
+        $this->updateCacheStatistics($operation, $cacheKey, $result);
+    }
+
+    /**
+     * Event-spezifische Metriken tracken
+     */
+    private function trackEventSpecificMetrics($event, string $eventName): void
+    {
+        if (!$this->config['detailed_sub_measurements']) {
+            return;
+        }
+
+        // Event-Serialization messen (falls Event serialisiert wird)
+        if (method_exists($event, 'serialize')) {
+            $this->meter->measure("event_serialization_{$eventName}", function() use ($event) {
+                $event->serialize();
+            }, PerformanceCategory::EVENT);
+        }
+
+        // Event-Validation messen
+        if (method_exists($event, 'validate')) {
+            $this->meter->measure("event_validation_{$eventName}", function() use ($event) {
+                $event->validate();
+            }, PerformanceCategory::VALIDATION);
+        }
+
+        // Listener-Count als Marker
+        $listenerCount = $this->getListenerCount($eventName);
+        if ($listenerCount > 5) {
+            $this->meter->mark("many_listeners_{$eventName}", PerformanceCategory::EVENT);
+        }
+    }
+
+    /**
+     * Langsame Events behandeln
+     */
+    private function handleSlowEvent($event, float $duration): void
+    {
+        $eventName = $this->getEventName($event);
+
+        // Warnung loggen
+        error_log("SLOW EVENT WARNING: {$eventName} took {$duration}ms");
+
+        // Detaillierte Informationen sammeln
+        $report = $this->meter->generateReport();
+        $slowOperations = [];
+
+        foreach ($report['measurements'] as $label => $data) {
+            if ($data['avg_time_ms'] > 50) { // Operationen > 50ms
+                $slowOperations[] = "{$label}: {$data['avg_time_ms']}ms";
+            }
+        }
+
+        if (!empty($slowOperations)) {
+            error_log("SLOW EVENT DETAILS: " . implode(', ', $slowOperations));
+        }
+
+        // Für kritische Events: Alert senden
+        if ($this->isCriticalEvent($eventName) && $duration > 1000) {
+            $this->sendPerformanceAlert($eventName, $duration);
+        }
+    }
+
+    /**
+     * Event-Performance loggen
+     */
+    private function logEventPerformance($event, float $duration, float $memoryMb): void
+    {
+        $eventName = $this->getEventName($event);
+
+        // Entscheidung: Wann loggen?
+        $shouldLog = $this->config['track_all_events'] ||
+                    ($this->config['track_slow_events_only'] && $duration > $this->config['slow_event_threshold_ms']);
+
+        if (!$shouldLog) {
+            return;
+        }
+
+        $logData = [
+            'event_name' => $eventName,
+            'event_id' => $this->getEventId($event),
+            'duration_ms' => round($duration, 2),
+            'memory_mb' => round($memoryMb, 2),
+            'timestamp' => microtime(true),
+        ];
+
+        // Event-spezifische Daten hinzufügen
+        if (method_exists($event, 'getLogData')) {
+            $logData['event_data'] = $event->getLogData();
+        }
+
+        error_log('EVENT_PERFORMANCE: ' . json_encode($logData));
+    }
+
+    /**
+     * Event-Statistiken aktualisieren
+     */
+    private function updateEventStatistics(string $eventName, float $duration, float $memory): void
+    {
+        if (!isset($this->eventStatistics[$eventName])) {
+            $this->eventStatistics[$eventName] = [
+                'count' => 0,
+                'total_time_ms' => 0,
+                'total_memory_mb' => 0,
+                'min_time_ms' => PHP_FLOAT_MAX,
+                'max_time_ms' => 0,
+            ];
+        }
+
+        $stats = &$this->eventStatistics[$eventName];
+        $stats['count']++;
+        $stats['total_time_ms'] += $duration;
+        $stats['total_memory_mb'] += $memory;
+        $stats['min_time_ms'] = min($stats['min_time_ms'], $duration);
+        $stats['max_time_ms'] = max($stats['max_time_ms'], $duration);
+        $stats['avg_time_ms'] = $stats['total_time_ms'] / $stats['count'];
+        $stats['avg_memory_mb'] = $stats['total_memory_mb'] / $stats['count'];
+    }
+
+    /**
+     * Event-Statistiken abrufen
+     */
+    public function getEventStatistics(): array
+    {
+        return $this->eventStatistics;
+    }
+
+    /**
+     * Performance-Bericht für alle Events
+     */
+    public function generateEventPerformanceReport(): string
+    {
+        $report = "EVENT PERFORMANCE STATISTICS\n";
+        $report .= str_repeat('=', 50) . "\n";
+
+        foreach ($this->eventStatistics as $eventName => $stats) {
+            $report .= sprintf(
+                "%-30s Count: %4d | Avg: %6.2fms | Min: %6.2fms | Max: %6.2fms | Mem: %5.2fMB\n",
+                $eventName,
+                $stats['count'],
+                $stats['avg_time_ms'],
+                $stats['min_time_ms'],
+                $stats['max_time_ms'],
+                $stats['avg_memory_mb']
+            );
+        }
+
+        return $report;
+    }
+
+    // === HELPER-METHODEN ===
+
+    private function getEventName($event): string
+    {
+        return get_class($event);
+    }
+
+    private function getEventId($event): string
+    {
+        return method_exists($event, 'getId') ? $event->getId() : uniqid();
+    }
+
+    private function getListenerCount(string $eventName): int
+    {
+        // Dummy-Implementation - in echter Anwendung würde hier
+        // die Anzahl der registrierten Listener zurückgegeben
+        return rand(1, 10);
+    }
+
+    private function isCriticalEvent(string $eventName): bool
+    {
+        $criticalEvents = [
+            'OrderCreatedEvent',
+            'PaymentProcessedEvent',
+            'UserRegistrationEvent',
+            'SecurityAlertEvent',
+        ];
+
+        return in_array(basename($eventName), $criticalEvents);
+    }
+
+    private function sendPerformanceAlert(string $eventName, float $duration): void
+    {
+        // Dummy - in echter Implementierung: Slack, Email, SMS, etc.
+        error_log("CRITICAL PERFORMANCE ALERT: {$eventName} took {$duration}ms");
+    }
+
+    // === DUMMY-IMPLEMENTIERUNGEN FÜR VOLLSTÄNDIGE BEISPIELE ===
+
+    private function validateUserEmail(string $email): bool
+    {
+        usleep(5000); // 5ms simulierte Email-Validierung
+        return filter_var($email, FILTER_VALIDATE_EMAIL) !== false;
+    }
+
+    private function hashUserPassword(string $password): string
+    {
+        usleep(100000); // 100ms simuliertes Password-Hashing (realistisch)
+        return password_hash($password, PASSWORD_DEFAULT);
+    }
+
+    private function insertUserToDatabase(array $userData): bool
+    {
+        usleep(25000); // 25ms simulierter DB-Insert
+        return true;
+    }
+
+    private function queueWelcomeEmail($user): void
+    {
+        usleep(2000); // 2ms für Queue-Operation
+    }
+
+    private function checkOrderInventory(array $items): bool
+    {
+        usleep(15000); // 15ms simulierte Inventory-Prüfung
+        return true;
+    }
+
+    private function processOrderPayment(array $paymentData): bool
+    {
+        usleep(200000); // 200ms simulierte Payment-Verarbeitung (realistisch)
+        return true;
+    }
+
+    private function calculateOrderTax(array $order): float
+    {
+        usleep(10000); // 10ms simulierte Tax-Berechnung
+        return 19.99;
+    }
+
+    private function sendOrderConfirmation(array $order): void
+    {
+        usleep(50000); // 50ms simulierte Email-Versendung
+    }
+
+    private function updateInventoryAfterOrder(array $items): void
+    {
+        usleep(20000); // 20ms simuliertes Inventory-Update
+    }
+
+    private function validateUploadedFile($file): bool
+    {
+        usleep(8000); // 8ms simulierte File-Validierung
+        return true;
+    }
+
+    private function scanFileForViruses($file): bool
+    {
+        usleep(150000); // 150ms simulierter Virus-Scan
+        return true;
+    }
+
+    private function isImage(string $fileName): bool
+    {
+        $imageExtensions = ['jpg', 'jpeg', 'png', 'gif', 'webp'];
+        $extension = strtolower(pathinfo($fileName, PATHINFO_EXTENSION));
+        return in_array($extension, $imageExtensions);
+    }
+
+    private function processUploadedImage($file): void
+    {
+        usleep(75000); // 75ms simulierte Image-Verarbeitung
+    }
+
+    private function storeFile($file, string $path): bool
+    {
+        usleep(30000); // 30ms simulierte File-Storage
+        return true;
+    }
+
+    private function extractFileMetadata($file): array
+    {
+        usleep(12000); // 12ms simulierte Metadata-Extraktion
+        return ['size' => 1024, 'type' => 'image/jpeg'];
+    }
+
+    private function executeCacheOperation($event): mixed
+    {
+        $operation = $event->getOperation();
+        $delay = [
+            'get' => 2000,    // 2ms
+            'set' => 5000,    // 5ms
+            'delete' => 3000, // 3ms
+            'flush' => 50000, // 50ms
+        ];
+
+        usleep($delay[$operation] ?? 1000);
+
+        return $operation === 'get' ? (rand(0, 1) ? 'cached_value' : null) : true;
+    }
+
+    private function updateCacheStatistics(string $operation, string $key, $result): void
+    {
+        // Dummy - Cache-Statistiken würden hier aktualisiert
+    }
+}
diff --git a/src/Framework/Performance/Examples/PerformanceMiddlewareExample.php b/src/Framework/Performance/Examples/PerformanceMiddlewareExample.php
new file mode 100644
index 00000000..cb06ddfc
--- /dev/null
+++ b/src/Framework/Performance/Examples/PerformanceMiddlewareExample.php
@@ -0,0 +1,406 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Performance\Examples;
+
+use App\Framework\Performance\PerformanceMeter;
+use App\Framework\Performance\PerformanceCategory;
+
+/**
+ * Beispiel-Middleware für HTTP-Request Performance-Tracking
+ *
+ * Diese Middleware zeigt, wie Performance-Messungen in einer typischen
+ * HTTP-Request-Pipeline implementiert werden können.
+ */
+class PerformanceMiddlewareExample
+{
+    private PerformanceMeter $meter;
+    private array $config;
+
+    public function __construct(PerformanceMeter $meter, array $config = [])
+    {
+        $this->meter = $meter;
+        $this->config = array_merge([
+            'track_all_requests' => true,
+            'track_slow_requests_only' => false,
+            'slow_threshold_ms' => 1000,
+            'add_response_headers' => true,
+            'detailed_measurement' => true,
+        ], $config);
+    }
+
+    /**
+     * Hauptmethode der Middleware - umschließt den Request-Prozess
+     */
+    public function handle($request, callable $next)
+    {
+        // === REQUEST START TRACKING ===
+        $this->meter->mark('request_received', PerformanceCategory::FRAMEWORK);
+
+        $startMemory = memory_get_usage(true);
+        $requestId = $this->generateRequestId();
+
+        // Request-Kontext für spätere Analyse sammeln
+        $requestContext = $this->captureRequestContext($request);
+
+        // === PRE-PROCESSING MEASUREMENT ===
+        $this->meter->startMeasure('request_preprocessing', PerformanceCategory::FRAMEWORK);
+        $this->preprocessRequest($request);
+        $this->meter->endMeasure('request_preprocessing');
+
+        // === AUTHENTICATION MEASUREMENT ===
+        if ($this->shouldTrackAuth($request)) {
+            $this->meter->startMeasure('authentication', PerformanceCategory::SECURITY);
+            $authResult = $this->authenticateRequest($request);
+            $this->meter->endMeasure('authentication');
+
+            $this->meter->mark('auth_completed', PerformanceCategory::SECURITY);
+        }
+
+        // === AUTHORIZATION MEASUREMENT ===
+        if ($this->shouldTrackAuthz($request)) {
+            $this->meter->startMeasure('authorization', PerformanceCategory::SECURITY);
+            $authzResult = $this->authorizeRequest($request);
+            $this->meter->endMeasure('authorization');
+
+            if (!$authzResult) {
+                $this->meter->mark('authorization_failed', PerformanceCategory::SECURITY);
+            }
+        }
+
+        // === CORE REQUEST PROCESSING ===
+        $this->meter->mark('core_processing_start', PerformanceCategory::FRAMEWORK);
+        $this->meter->startMeasure('core_request_processing', PerformanceCategory::CONTROLLER);
+
+        // Hier würde der eigentliche Request-Handler aufgerufen
+        $response = $next($request);
+
+        $this->meter->endMeasure('core_request_processing');
+        $this->meter->mark('core_processing_end', PerformanceCategory::FRAMEWORK);
+
+        // === RESPONSE PROCESSING MEASUREMENT ===
+        $this->meter->startMeasure('response_processing', PerformanceCategory::FRAMEWORK);
+        $response = $this->processResponse($response, $requestContext);
+        $this->meter->endMeasure('response_processing');
+
+        // === LOGGING & CLEANUP MEASUREMENT ===
+        $this->meter->startMeasure('logging_cleanup', PerformanceCategory::FRAMEWORK);
+        $this->logRequestMetrics($requestId, $requestContext, $startMemory);
+        $this->meter->endMeasure('logging_cleanup');
+
+        // === FINAL MARKERS ===
+        $this->meter->mark('request_completed', PerformanceCategory::FRAMEWORK);
+
+        // === PERFORMANCE HEADERS HINZUFÜGEN ===
+        if ($this->config['add_response_headers']) {
+            $this->addPerformanceHeaders($response);
+        }
+
+        // === PERFORMANCE-DATEN AUSGEBEN/LOGGEN ===
+        $this->outputPerformanceData($requestId, $requestContext);
+
+        return $response;
+    }
+
+    /**
+     * Request-Preprocessing mit detaillierter Messung
+     */
+    private function preprocessRequest($request): void
+    {
+        // Input-Validierung messen
+        $this->meter->measure('input_validation', function() use ($request) {
+            $this->validateInput($request);
+        }, PerformanceCategory::VALIDATION);
+
+        // Request-Parsing messen
+        $this->meter->measure('request_parsing', function() use ($request) {
+            $this->parseRequestData($request);
+        }, PerformanceCategory::FRAMEWORK);
+
+        // Rate-Limiting prüfen
+        $this->meter->measure('rate_limiting', function() use ($request) {
+            $this->checkRateLimit($request);
+        }, PerformanceCategory::SECURITY);
+    }
+
+    /**
+     * Authentication mit Performance-Tracking
+     */
+    private function authenticateRequest($request): bool
+    {
+        // Session-Check
+        $sessionValid = $this->meter->measure('session_validation', function() use ($request) {
+            return $this->validateSession($request);
+        }, PerformanceCategory::SECURITY);
+
+        if ($sessionValid) {
+            $this->meter->mark('session_auth_success', PerformanceCategory::SECURITY);
+            return true;
+        }
+
+        // Token-Authentication
+        $tokenValid = $this->meter->measure('token_validation', function() use ($request) {
+            return $this->validateToken($request);
+        }, PerformanceCategory::SECURITY);
+
+        if ($tokenValid) {
+            $this->meter->mark('token_auth_success', PerformanceCategory::SECURITY);
+            return true;
+        }
+
+        // Database-Authentication (langsam)
+        $dbAuth = $this->meter->measure('database_authentication', function() use ($request) {
+            return $this->authenticateAgainstDatabase($request);
+        }, PerformanceCategory::DATABASE);
+
+        if ($dbAuth) {
+            $this->meter->mark('db_auth_success', PerformanceCategory::SECURITY);
+        } else {
+            $this->meter->mark('auth_failed', PerformanceCategory::SECURITY);
+        }
+
+        return $dbAuth;
+    }
+
+    /**
+     * Response-Processing mit Messungen
+     */
+    private function processResponse($response, array $context)
+    {
+        // Content-Transformation
+        $this->meter->measure('content_transformation', function() use ($response) {
+            $this->transformResponseContent($response);
+        }, PerformanceCategory::VIEW);
+
+        // Caching-Headers setzen
+        $this->meter->measure('cache_headers', function() use ($response, $context) {
+            $this->setCacheHeaders($response, $context);
+        }, PerformanceCategory::CACHE);
+
+        // Compression
+        if ($this->shouldCompress($response)) {
+            $this->meter->measure('response_compression', function() use ($response) {
+                $this->compressResponse($response);
+            }, PerformanceCategory::FRAMEWORK);
+        }
+
+        return $response;
+    }
+
+    /**
+     * Performance-Headers zum Response hinzufügen
+     */
+    private function addPerformanceHeaders($response): void
+    {
+        $report = $this->meter->generateReport();
+
+        // Basis-Performance-Daten
+        $response->headers['X-Performance-Time'] = sprintf('%.2fms', $report['summary']['total_time_ms']);
+        $response->headers['X-Performance-Memory'] = sprintf('%.2fMB', $report['summary']['total_memory_mb']);
+        $response->headers['X-Performance-Markers'] = (string) $report['summary']['marker_count'];
+
+        // Detaillierte Kategorie-Zeiten
+        foreach ($report['categories'] as $category => $data) {
+            if (isset($data['total_time_ms'])) {
+                $headerName = 'X-Performance-' . ucfirst($category);
+                $response->headers[$headerName] = sprintf('%.2fms', $data['total_time_ms']);
+            }
+        }
+
+        // Langsame Operationen hervorheben
+        $slowOperations = $this->findSlowOperations($report);
+        if (!empty($slowOperations)) {
+            $response->headers['X-Performance-Slow-Ops'] = implode(',', $slowOperations);
+        }
+
+        // Memory-Peak
+        $response->headers['X-Performance-Memory-Peak'] = sprintf('%.2fMB', memory_get_peak_usage(true) / 1024 / 1024);
+    }
+
+    /**
+     * Performance-Daten ausgeben oder loggen
+     */
+    private function outputPerformanceData(string $requestId, array $context): void
+    {
+        $report = $this->meter->generateReport();
+        $totalTime = $report['summary']['total_time_ms'];
+
+        // Entscheidung: Wann sollen Performance-Daten ausgegeben werden?
+        $shouldOutput = $this->config['track_all_requests'] ||
+                       ($this->config['track_slow_requests_only'] && $totalTime > $this->config['slow_threshold_ms']);
+
+        if (!$shouldOutput) {
+            return;
+        }
+
+        // Für Development: Detaillierte Ausgabe
+        if ($this->isDebugMode()) {
+            echo "\n" . str_repeat('=', 50) . "\n";
+            echo "PERFORMANCE REPORT - Request: $requestId\n";
+            echo str_repeat('=', 50) . "\n";
+            echo $this->meter->generateTextReport();
+            echo str_repeat('=', 50) . "\n\n";
+        }
+
+        // Für Production: Strukturiertes Logging
+        $logData = [
+            'request_id' => $requestId,
+            'url' => $context['url'],
+            'method' => $context['method'],
+            'total_time_ms' => $totalTime,
+            'memory_mb' => $report['summary']['total_memory_mb'],
+            'slow_operations' => $this->findSlowOperations($report),
+            'category_breakdown' => $this->getCategoryBreakdown($report),
+            'context' => $context,
+        ];
+
+        error_log('PERFORMANCE: ' . json_encode($logData));
+
+        // Bei sehr langsamen Requests: Warnung
+        if ($totalTime > $this->config['slow_threshold_ms'] * 2) {
+            error_log("SLOW REQUEST WARNING: {$context['url']} took {$totalTime}ms");
+        }
+    }
+
+    /**
+     * Request-Kontext für Analyse sammeln
+     */
+    private function captureRequestContext($request): array
+    {
+        return [
+            'url' => $request->getUri ?? $_SERVER['REQUEST_URI'] ?? 'unknown',
+            'method' => $request->getMethod ?? $_SERVER['REQUEST_METHOD'] ?? 'unknown',
+            'user_agent' => $request->getUserAgent ?? $_SERVER['HTTP_USER_AGENT'] ?? 'unknown',
+            'ip' => $request->getClientIp ?? $_SERVER['REMOTE_ADDR'] ?? 'unknown',
+            'content_length' => $request->getContentLength ?? $_SERVER['CONTENT_LENGTH'] ?? 0,
+            'timestamp' => microtime(true),
+        ];
+    }
+
+    /**
+     * Langsame Operationen identifizieren
+     */
+    private function findSlowOperations(array $report): array
+    {
+        $slowOps = [];
+        $threshold = 100; // ms
+
+        foreach ($report['measurements'] as $label => $data) {
+            if ($data['avg_time_ms'] > $threshold) {
+                $slowOps[] = "{$label}:{$data['avg_time_ms']}ms";
+            }
+        }
+
+        return $slowOps;
+    }
+
+    /**
+     * Kategorie-Breakdown für Logging
+     */
+    private function getCategoryBreakdown(array $report): array
+    {
+        $breakdown = [];
+
+        foreach ($report['categories'] as $category => $data) {
+            if (isset($data['total_time_ms'])) {
+                $breakdown[$category] = [
+                    'time_ms' => $data['total_time_ms'],
+                    'count' => $data['count'],
+                    'avg_ms' => $data['avg_time_ms'],
+                ];
+            }
+        }
+
+        return $breakdown;
+    }
+
+    // === DUMMY-METHODEN FÜR VOLLSTÄNDIGES BEISPIEL ===
+
+    private function generateRequestId(): string
+    {
+        return uniqid('req_', true);
+    }
+
+    private function shouldTrackAuth($request): bool
+    {
+        return true; // In echter Implementierung: Prüfung ob Auth nötig
+    }
+
+    private function shouldTrackAuthz($request): bool
+    {
+        return true; // In echter Implementierung: Prüfung ob Authz nötig
+    }
+
+    private function validateInput($request): void
+    {
+        // Dummy: Input-Validierung
+        usleep(5000); // 5ms simulierte Verarbeitung
+    }
+
+    private function parseRequestData($request): void
+    {
+        // Dummy: Request-Parsing
+        usleep(2000); // 2ms simulierte Verarbeitung
+    }
+
+    private function checkRateLimit($request): void
+    {
+        // Dummy: Rate-Limiting
+        usleep(1000); // 1ms simulierte Verarbeitung
+    }
+
+    private function validateSession($request): bool
+    {
+        usleep(10000); // 10ms simulierte Session-Validierung
+        return rand(0, 1) === 1;
+    }
+
+    private function validateToken($request): bool
+    {
+        usleep(5000); // 5ms simulierte Token-Validierung
+        return rand(0, 1) === 1;
+    }
+
+    private function authenticateAgainstDatabase($request): bool
+    {
+        usleep(50000); // 50ms simulierte DB-Authentication
+        return true;
+    }
+
+    private function authorizeRequest($request): bool
+    {
+        usleep(15000); // 15ms simulierte Authorization
+        return true;
+    }
+
+    private function transformResponseContent($response): void
+    {
+        usleep(8000); // 8ms simulierte Content-Transformation
+    }
+
+    private function setCacheHeaders($response, $context): void
+    {
+        usleep(1000); // 1ms simulierte Cache-Header
+    }
+
+    private function shouldCompress($response): bool
+    {
+        return true;
+    }
+
+    private function compressResponse($response): void
+    {
+        usleep(20000); // 20ms simulierte Kompression
+    }
+
+    private function logRequestMetrics($requestId, $context, $startMemory): void
+    {
+        usleep(3000); // 3ms simuliertes Logging
+    }
+
+    private function isDebugMode(): bool
+    {
+        return $_ENV['DEBUG'] ?? false;
+    }
+}
diff --git a/src/Framework/Performance/Examples/README.md b/src/Framework/Performance/Examples/README.md
new file mode 100644
index 00000000..81daebae
--- /dev/null
+++ b/src/Framework/Performance/Examples/README.md
@@ -0,0 +1,18 @@
+# Performance Monitoring Examples
+
+Dieser Ordner enthält praktische Beispiele für die Verwendung des Performance-Monitoring-Systems in verschiedenen Szenarien.
+
+## Beispiele
+
+### 1. PerformanceMiddlewareExample.php
+
+**Zweck**: Zeigt, wie Performance-Tracking in HTTP-Request-Middleware implementiert wird.
+
+**Key Features**:
+- ✅ Request-Lifecycle-Tracking
+- ✅ Authentication/Authorization-Messungen
+- ✅ Response-Processing-Tracking
+- ✅ Performance-Headers
+- ✅ Slow-Request-Detection
+
+**Verwendung**:
diff --git a/src/Framework/Performance/Jobs/ProcessPerformanceLogsJob.php b/src/Framework/Performance/Jobs/ProcessPerformanceLogsJob.php
new file mode 100644
index 00000000..66490af6
--- /dev/null
+++ b/src/Framework/Performance/Jobs/ProcessPerformanceLogsJob.php
@@ -0,0 +1,30 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Performance\Jobs;
+
+use App\Framework\Jobs\Job;
+use App\Framework\Performance\PerformanceDatabaseWorker;
+use App\Framework\Core\Container;
+
+class ProcessPerformanceLogsJob extends Job
+{
+    private string $logFile;
+
+    public function __construct(string $logFile)
+    {
+        $this->logFile = $logFile;
+    }
+
+    public function handle(Container $container): void
+    {
+        $worker = $container->get(PerformanceDatabaseWorker::class);
+        $worker->processLogFile($this->logFile);
+    }
+
+    public function getLogFile(): string
+    {
+        return $this->logFile;
+    }
+}
diff --git a/src/Framework/Performance/MemoryUsageTracker.php b/src/Framework/Performance/MemoryUsageTracker.php
new file mode 100644
index 00000000..a4fe4213
--- /dev/null
+++ b/src/Framework/Performance/MemoryUsageTracker.php
@@ -0,0 +1,132 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Performance;
+
+/**
+ * Tracking von Speicherverbrauch und Performance-Metriken.
+ */
+final class MemoryUsageTracker
+{
+    /**
+     * @var array<string, float> Speichert Start-Zeitstempel für Messungen
+     */
+    private array $timers = [];
+
+    /**
+     * @var array<string, int> Speichert Speicherverbrauch zu Beginn einer Messung
+     */
+    private array $memoryUsage = [];
+
+    /**
+     * @var array<string, array{time: float, memory: int}> Gespeicherte Messpunkte
+     */
+    private array $measurements = [];
+
+    /**
+     * Startet eine neue Zeitmessung.
+     */
+    public function startTimer(string $name): void
+    {
+        $this->timers[$name] = microtime(true);
+        $this->memoryUsage[$name] = memory_get_usage(true);
+    }
+
+    /**
+     * Beendet eine Zeitmessung und gibt die verstrichene Zeit in Sekunden zurück.
+     */
+    public function stopTimer(string $name): float
+    {
+        if (!isset($this->timers[$name])) {
+            return 0.0;
+        }
+
+        $startTime = $this->timers[$name];
+        $startMemory = $this->memoryUsage[$name];
+
+        $endTime = microtime(true);
+        $endMemory = memory_get_usage(true);
+
+        $timeElapsed = $endTime - $startTime;
+        $memoryDiff = $endMemory - $startMemory;
+
+        $this->measurements[$name] = [
+            'time' => $timeElapsed,
+            'memory' => $memoryDiff,
+        ];
+
+        unset($this->timers[$name]);
+        unset($this->memoryUsage[$name]);
+
+        return $timeElapsed;
+    }
+
+    /**
+     * Gibt alle gespeicherten Messungen zurück.
+     *
+     * @return array<string, array{time: float, memory: int}>
+     */
+    public function getMeasurements(): array
+    {
+        return $this->measurements;
+    }
+
+    /**
+     * Gibt die Messung für einen bestimmten Namen zurück.
+     *
+     * @return array{time: float, memory: int}|null
+     */
+    public function getMeasurement(string $name): ?array
+    {
+        return $this->measurements[$name] ?? null;
+    }
+
+    /**
+     * Misst die Ausführungszeit einer Funktion.
+     *
+     * @param callable $callback Die auszuführende Funktion
+     * @param string $name Ein Name für diese Messung
+     * @return mixed Der Rückgabewert der Funktion
+     */
+    public function measure(callable $callback, string $name): mixed
+    {
+        $this->startTimer($name);
+        $result = $callback();
+        $this->stopTimer($name);
+
+        return $result;
+    }
+
+    /**
+     * Gibt den aktuellen Speicherverbrauch in einem lesbaren Format zurück.
+     */
+    public function getCurrentMemoryUsage(bool $realUsage = true): string
+    {
+        return $this->formatBytes(memory_get_usage($realUsage));
+    }
+
+    /**
+     * Gibt den maximalen Speicherverbrauch in einem lesbaren Format zurück.
+     */
+    public function getPeakMemoryUsage(bool $realUsage = true): string
+    {
+        return $this->formatBytes(memory_get_peak_usage($realUsage));
+    }
+
+    /**
+     * Formatiert Bytes in ein lesbares Format.
+     */
+    public function formatBytes(int $bytes, int $precision = 2): string
+    {
+        $units = ['B', 'KB', 'MB', 'GB', 'TB'];
+
+        $bytes = max($bytes, 0);
+        $pow = floor(($bytes ? log($bytes) : 0) / log(1024));
+        $pow = min($pow, count($units) - 1);
+
+        $bytes /= (1 << (10 * $pow));
+
+        return round($bytes, $precision) . ' ' . $units[$pow];
+    }
+}
diff --git a/src/Framework/Performance/PerformanceCategory.php b/src/Framework/Performance/PerformanceCategory.php
new file mode 100644
index 00000000..4f1e0c2c
--- /dev/null
+++ b/src/Framework/Performance/PerformanceCategory.php
@@ -0,0 +1,24 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Performance;
+
+enum PerformanceCategory: string
+{
+    case SYSTEM = 'system';
+    case DATABASE = 'database';
+    case CACHE = 'cache';
+    case TEMPLATE = 'template';
+    case ROUTING = 'routing';
+    case CONTROLLER = 'controller';
+    case VIEW = 'view';
+    case API = 'api';
+    case FILESYSTEM = 'filesystem';
+    case CUSTOM = 'custom';
+
+    public static function fromString(string $value): self
+    {
+        return self::tryFrom($value) ?? self::CUSTOM;
+    }
+}
diff --git a/src/Framework/Performance/PerformanceDatabaseWorker.php b/src/Framework/Performance/PerformanceDatabaseWorker.php
new file mode 100644
index 00000000..476a621b
--- /dev/null
+++ b/src/Framework/Performance/PerformanceDatabaseWorker.php
@@ -0,0 +1,298 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Performance;
+
+use App\Framework\Database\Connection;
+use App\Framework\DateTime\Clock;
+
+class PerformanceDatabaseWorker
+{
+    private Connection $connection;
+    private Clock $clock;
+    private array $config;
+
+    public function __construct(Connection $connection, Clock $clock, array $config = [])
+    {
+        $this->connection = $connection;
+        $this->clock = $clock;
+        $this->config = array_merge([
+            'batch_size' => 100,
+            'create_tables' => true,
+            'table_prefix' => 'performance_',
+        ], $config);
+
+        if ($this->config['create_tables']) {
+            $this->ensureTables();
+        }
+    }
+
+    public function processLogFile(string $logFile): void
+    {
+        if (!file_exists($logFile)) {
+            return;
+        }
+
+        $tempFile = $logFile . '.processing';
+
+        // Datei atomar umbenennen für Processing
+        if (!rename($logFile, $tempFile)) {
+            return;
+        }
+
+        try {
+            $this->processFile($tempFile);
+            unlink($tempFile); // Erfolgreich verarbeitet
+        } catch (\Exception $e) {
+            // Bei Fehler Datei zurück umbenennen
+            rename($tempFile, $logFile);
+            error_log("Performance log processing failed: " . $e->getMessage());
+            throw $e;
+        }
+    }
+
+    private function processFile(string $file): void
+    {
+        $lines = file($file, FILE_IGNORE_NEW_LINES | FILE_SKIP_EMPTY_LINES);
+        if (empty($lines)) {
+            return;
+        }
+
+        $logBatch = [];
+        $measurementBatch = [];
+
+        foreach ($lines as $line) {
+            $data = json_decode($line, true);
+            if (!$data) {
+                continue;
+            }
+
+            $logId = $this->prepareLogEntry($data, $logBatch);
+            $this->prepareMeasurementEntries($data, $logId, $measurementBatch);
+
+            // Batch-Verarbeitung
+            if (count($logBatch) >= $this->config['batch_size']) {
+                $this->insertBatches($logBatch, $measurementBatch);
+                $logBatch = [];
+                $measurementBatch = [];
+            }
+        }
+
+        // Rest verarbeiten
+        if (!empty($logBatch)) {
+            $this->insertBatches($logBatch, $measurementBatch);
+        }
+    }
+
+    private function prepareLogEntry(array $data, array &$logBatch): string
+    {
+        $logId = uniqid('log_', true);
+
+        $logBatch[] = [
+            'id' => $logId,
+            'timestamp' => $data['timestamp'],
+            'request_id' => $data['request_id'],
+            'url' => $data['url'],
+            'method' => $data['method'],
+            'total_time_ms' => $data['performance']['summary']['total_time_ms'],
+            'memory_mb' => $data['performance']['summary']['total_memory_mb'],
+            'memory_peak_mb' => $data['memory_peak_mb'],
+            'marker_count' => $data['performance']['summary']['marker_count'],
+            'user_agent' => $data['user_agent'] ?? null,
+            'data' => json_encode($data['performance']),
+            'context' => json_encode($data['context'] ?? []),
+            'server_data' => json_encode($data['server_data'] ?? []),
+            'created_at' => $this->clock->now()->format('Y-m-d H:i:s'),
+        ];
+
+        return $logId;
+    }
+
+    private function prepareMeasurementEntries(array $data, string $logId, array &$measurementBatch): void
+    {
+        foreach ($data['performance']['measurements'] ?? [] as $label => $measurement) {
+            $measurementBatch[] = [
+                'log_id' => $logId,
+                'category' => $measurement['category'],
+                'label' => $label,
+                'count' => $measurement['count'],
+                'total_time_ms' => $measurement['total_time_ms'],
+                'avg_time_ms' => $measurement['avg_time_ms'],
+                'min_time_ms' => $measurement['min_time_ms'],
+                'max_time_ms' => $measurement['max_time_ms'],
+                'total_memory_mb' => $measurement['total_memory_mb'],
+                'avg_memory_mb' => $measurement['avg_memory_mb'],
+            ];
+        }
+    }
+
+    private function insertBatches(array $logBatch, array $measurementBatch): void
+    {
+        $pdo = $this->connection->getPdo();
+
+        $pdo->beginTransaction();
+
+        try {
+            // Performance Logs einfügen
+            if (!empty($logBatch)) {
+                $this->insertPerformanceLogs($pdo, $logBatch);
+            }
+
+            // Measurements einfügen
+            if (!empty($measurementBatch)) {
+                $this->insertMeasurements($pdo, $measurementBatch);
+            }
+
+            $pdo->commit();
+
+        } catch (\Exception $e) {
+            $pdo->rollBack();
+            throw $e;
+        }
+    }
+
+    private function insertPerformanceLogs(\PDO $pdo, array $batch): void
+    {
+        $tableName = $this->config['table_prefix'] . 'logs';
+
+        $sql = "INSERT INTO {$tableName} (
+            id, timestamp, request_id, url, method, total_time_ms, memory_mb,
+            memory_peak_mb, marker_count, user_agent, data, context, server_data, created_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)";
+
+        $stmt = $pdo->prepare($sql);
+
+        foreach ($batch as $entry) {
+            $stmt->execute([
+                $entry['id'],
+                $entry['timestamp'],
+                $entry['request_id'],
+                $entry['url'],
+                $entry['method'],
+                $entry['total_time_ms'],
+                $entry['memory_mb'],
+                $entry['memory_peak_mb'],
+                $entry['marker_count'],
+                $entry['user_agent'],
+                $entry['data'],
+                $entry['context'],
+                $entry['server_data'],
+                $entry['created_at'],
+            ]);
+        }
+    }
+
+    private function insertMeasurements(\PDO $pdo, array $batch): void
+    {
+        $tableName = $this->config['table_prefix'] . 'measurements';
+
+        $sql = "INSERT INTO {$tableName} (
+            log_id, category, label, count, total_time_ms, avg_time_ms,
+            min_time_ms, max_time_ms, total_memory_mb, avg_memory_mb
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)";
+
+        $stmt = $pdo->prepare($sql);
+
+        foreach ($batch as $entry) {
+            $stmt->execute([
+                $entry['log_id'],
+                $entry['category'],
+                $entry['label'],
+                $entry['count'],
+                $entry['total_time_ms'],
+                $entry['avg_time_ms'],
+                $entry['min_time_ms'],
+                $entry['max_time_ms'],
+                $entry['total_memory_mb'],
+                $entry['avg_memory_mb'],
+            ]);
+        }
+    }
+
+    private function ensureTables(): void
+    {
+        $pdo = $this->connection->getPdo();
+        $tablePrefix = $this->config['table_prefix'];
+
+        // Performance Logs Tabelle
+        $pdo->exec("
+            CREATE TABLE IF NOT EXISTS {$tablePrefix}logs (
+                id VARCHAR(255) PRIMARY KEY,
+                timestamp DATETIME NOT NULL,
+                request_id VARCHAR(255) NOT NULL,
+                url VARCHAR(500) NOT NULL,
+                method VARCHAR(10) NOT NULL,
+                total_time_ms DECIMAL(10,2) NOT NULL,
+                memory_mb DECIMAL(10,2) NOT NULL,
+                memory_peak_mb DECIMAL(10,2) NOT NULL,
+                marker_count INT NOT NULL,
+                user_agent TEXT,
+                data JSON,
+                context JSON,
+                server_data JSON,
+                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+
+                INDEX idx_timestamp (timestamp),
+                INDEX idx_url (url(100)),
+                INDEX idx_method (method),
+                INDEX idx_total_time (total_time_ms),
+                INDEX idx_request_id (request_id),
+                INDEX idx_created_at (created_at)
+            )
+        ");
+
+        // Measurements Tabelle
+        $pdo->exec("
+            CREATE TABLE IF NOT EXISTS {$tablePrefix}measurements (
+                id BIGINT PRIMARY KEY AUTO_INCREMENT,
+                log_id VARCHAR(255) NOT NULL,
+                category VARCHAR(50) NOT NULL,
+                label VARCHAR(100) NOT NULL,
+                count INT NOT NULL,
+                total_time_ms DECIMAL(10,2) NOT NULL,
+                avg_time_ms DECIMAL(10,2) NOT NULL,
+                min_time_ms DECIMAL(10,2) NOT NULL,
+                max_time_ms DECIMAL(10,2) NOT NULL,
+                total_memory_mb DECIMAL(10,2) NOT NULL,
+                avg_memory_mb DECIMAL(10,2) NOT NULL,
+
+                FOREIGN KEY (log_id) REFERENCES {$tablePrefix}logs(id) ON DELETE CASCADE,
+                INDEX idx_log_id (log_id),
+                INDEX idx_category (category),
+                INDEX idx_label (label),
+                INDEX idx_avg_time (avg_time_ms)
+            )
+        ");
+    }
+
+    public function getStatistics(): array
+    {
+        $pdo = $this->connection->getPdo();
+        $tablePrefix = $this->config['table_prefix'];
+
+        $stmt = $pdo->query("
+            SELECT
+                COUNT(*) as total_logs,
+                AVG(total_time_ms) as avg_response_time,
+                MAX(total_time_ms) as max_response_time,
+                AVG(memory_mb) as avg_memory,
+                MAX(memory_mb) as max_memory
+            FROM {$tablePrefix}logs
+            WHERE created_at > DATE_SUB(NOW(), INTERVAL 24 HOUR)
+        ");
+
+        return $stmt->fetch(\PDO::FETCH_ASSOC) ?: [];
+    }
+
+    public function cleanup(int $retentionDays = 30): void
+    {
+        $pdo = $this->connection->getPdo();
+        $tablePrefix = $this->config['table_prefix'];
+
+        $pdo->exec("
+            DELETE FROM {$tablePrefix}logs
+            WHERE created_at < DATE_SUB(NOW(), INTERVAL {$retentionDays} DAY)
+        ");
+    }
+}
diff --git a/src/Framework/Performance/PerformanceFileLogger.php b/src/Framework/Performance/PerformanceFileLogger.php
new file mode 100644
index 00000000..a9566b09
--- /dev/null
+++ b/src/Framework/Performance/PerformanceFileLogger.php
@@ -0,0 +1,169 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Performance;
+
+use App\Framework\Core\PathProvider;
+use App\Framework\DateTime\Clock;
+use App\Framework\Jobs\JobQueue;
+
+class PerformanceFileLogger
+{
+    private array $buffer = [];
+    private string $logFile;
+    private Clock $clock;
+    private ?JobQueue $jobQueue;
+    private array $config;
+
+    public function __construct(
+        PathProvider $pathProvider,
+        Clock $clock,
+        ?JobQueue $jobQueue = null,
+        array $config = []
+    ) {
+        $this->clock = $clock;
+        $this->jobQueue = $jobQueue;
+        $this->config = array_merge([
+            'buffer_size' => 50,
+            'flush_interval' => 300, // 5 Minuten
+            'min_threshold_ms' => 0,
+            'background_processing' => true,
+            'include_request_data' => true,
+        ], $config);
+
+        $logDir = $pathProvider->getStoragePath('logs/performance');
+        $this->ensureLogDirectory($logDir);
+
+        $date = $this->clock->now()->format('Y-m-d');
+        $this->logFile = "{$logDir}/performance-{$date}.jsonl";
+
+        // Cleanup bei Script-Ende
+        register_shutdown_function([$this, 'shutdown']);
+    }
+
+    public function log(PerformanceMeter $meter, array $context = []): void
+    {
+        $report = $meter->generateReport();
+
+        // Schwellenwert prüfen
+        if ($report['summary']['total_time_ms'] < $this->config['min_threshold_ms']) {
+            return;
+        }
+
+        $data = [
+            'timestamp' => $this->clock->now()->format('c'),
+            'timestamp_float' => $this->clock->microtime(),
+            'request_id' => $this->generateRequestId(),
+            'url' => $_SERVER['REQUEST_URI'] ?? 'cli',
+            'method' => $_SERVER['REQUEST_METHOD'] ?? 'CLI',
+            'user_agent' => $_SERVER['HTTP_USER_AGENT'] ?? 'CLI',
+            'memory_peak_mb' => memory_get_peak_usage(true) / 1024 / 1024,
+            'performance' => $report,
+            'context' => $context,
+        ];
+
+        if ($this->config['include_request_data']) {
+            $data['server_data'] = $this->getServerData();
+        }
+
+        // In Buffer schreiben (extrem schnell)
+        $this->buffer[] = $data;
+
+        // Bei Puffergröße verarbeiten
+        if (count($this->buffer) >= $this->config['buffer_size']) {
+            $this->flushBuffer();
+        }
+    }
+
+    private function flushBuffer(): void
+    {
+        if (empty($this->buffer)) {
+            return;
+        }
+
+        // Schnell in File schreiben
+        $content = '';
+        foreach ($this->buffer as $entry) {
+            $content .= json_encode($entry, JSON_UNESCAPED_SLASHES) . "\n";
+        }
+
+        file_put_contents($this->logFile, $content, FILE_APPEND | LOCK_EX);
+
+        // Background-Verarbeitung anstoßen
+        if ($this->config['background_processing'] && $this->jobQueue) {
+            $this->scheduleBackgroundProcessing();
+        }
+
+        $this->buffer = [];
+    }
+
+    private function scheduleBackgroundProcessing(): void
+    {
+        // Job für die Verarbeitung in die Queue einreihen
+        $this->jobQueue->dispatch(new ProcessPerformanceLogsJob($this->logFile));
+    }
+
+    private function getServerData(): array
+    {
+        return [
+            'php_version' => PHP_VERSION,
+            'memory_limit' => ini_get('memory_limit'),
+            'max_execution_time' => ini_get('max_execution_time'),
+            'server_name' => $_SERVER['SERVER_NAME'] ?? 'unknown',
+            'remote_addr' => $_SERVER['REMOTE_ADDR'] ?? 'unknown',
+        ];
+    }
+
+    private function generateRequestId(): string
+    {
+        return uniqid('req_', true);
+    }
+
+    private function ensureLogDirectory(string $directory): void
+    {
+        if (!is_dir($directory)) {
+            mkdir($directory, 0755, true);
+        }
+    }
+
+    public function shutdown(): void
+    {
+        $this->flushBuffer();
+    }
+
+    public function getLogFile(): string
+    {
+        return $this->logFile;
+    }
+
+    public function setEnabled(bool $enabled): void
+    {
+        $this->config['enabled'] = $enabled;
+    }
+
+    public function isEnabled(): bool
+    {
+        return $this->config['enabled'] ?? true;
+    }
+
+    /**
+     * Bereinigt alte Log-Dateien
+     */
+    public function cleanup(int $retentionDays = 30): void
+    {
+        if ($retentionDays <= 0) {
+            return;
+        }
+
+        $cutoffTime = $this->clock->now()->getTimestamp() - ($retentionDays * 24 * 3600);
+        $logDir = dirname($this->logFile);
+        $files = glob($logDir . '/performance-*.jsonl');
+
+        foreach ($files as $file) {
+            if (filemtime($file) < $cutoffTime) {
+                unlink($file);
+            }
+        }
+    }
+}
diff --git a/src/Framework/Performance/PerformanceMarker.php b/src/Framework/Performance/PerformanceMarker.php
new file mode 100644
index 00000000..6b64835e
--- /dev/null
+++ b/src/Framework/Performance/PerformanceMarker.php
@@ -0,0 +1,39 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Performance;
+
+readonly class PerformanceMarker
+{
+    public float $time;
+    public int $memory;
+
+    public function __construct(
+        public string              $label,
+        public PerformanceCategory $category,
+    ) {
+        $this->time = microtime(true);
+        $this->memory = memory_get_usage();
+    }
+
+    public function getLabel(): string
+    {
+        return $this->label;
+    }
+
+    public function getCategory(): PerformanceCategory
+    {
+        return $this->category;
+    }
+
+    public function getTime(): float
+    {
+        return $this->time;
+    }
+
+    public function getMemory(): int
+    {
+        return $this->memory;
+    }
+}
diff --git a/src/Framework/Performance/PerformanceMeasurement.php b/src/Framework/Performance/PerformanceMeasurement.php
new file mode 100644
index 00000000..43c05189
--- /dev/null
+++ b/src/Framework/Performance/PerformanceMeasurement.php
@@ -0,0 +1,82 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Performance;
+
+class PerformanceMeasurement
+{
+    public float $startTime;
+    public int $startMemory;
+    public ?float $endTime = null;
+    public ?int $endMemory = null;
+
+    public function __construct(
+        public readonly string $label,
+        public readonly PerformanceCategory $category,
+    ) {
+        $this->startTime = microtime(true);
+        $this->startMemory = memory_get_usage();
+    }
+
+    public function end(): void
+    {
+        if ($this->endTime === null) {
+            $this->endTime = microtime(true);
+            $this->endMemory = memory_get_usage();
+        }
+    }
+
+    public function isCompleted(): bool
+    {
+        return $this->endTime !== null;
+    }
+
+    public function getLabel(): string
+    {
+        return $this->label;
+    }
+
+    public function getCategory(): PerformanceCategory
+    {
+        return $this->category;
+    }
+
+    public function getDurationMs(): float
+    {
+        if ($this->endTime === null) {
+            return 0.0;
+        }
+
+        return ($this->endTime - $this->startTime) * 1000;
+    }
+
+    public function getMemoryUsageMb(): float
+    {
+        if ($this->endMemory === null) {
+            return 0.0;
+        }
+
+        return ($this->endMemory - $this->startMemory) / 1024 / 1024;
+    }
+
+    public function getStartTime(): float
+    {
+        return $this->startTime;
+    }
+
+    public function getEndTime(): ?float
+    {
+        return $this->endTime;
+    }
+
+    public function getStartMemory(): int
+    {
+        return $this->startMemory;
+    }
+
+    public function getEndMemory(): ?int
+    {
+        return $this->endMemory;
+    }
+}
diff --git a/src/Framework/Performance/PerformanceMeter.php b/src/Framework/Performance/PerformanceMeter.php
new file mode 100644
index 00000000..209eb846
--- /dev/null
+++ b/src/Framework/Performance/PerformanceMeter.php
@@ -0,0 +1,446 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Performance;
+
+class PerformanceMeter
+{
+    /** @var array<string, PerformanceMarker> */
+    private array $markers = [];
+
+    /** @var array<string, PerformanceMeasurement> */
+    private array $activeMeasurements = [];
+
+    /** @var array<string, array<int, PerformanceMeasurement>> */
+    private array $completedMeasurements = [];
+
+    private float $initTime;
+    private int $initMemory;
+    private bool $enabled;
+
+    public function __construct(bool $enabled = true)
+    {
+        $this->initTime = microtime(true);
+        $this->initMemory = memory_get_usage();
+        $this->enabled = $enabled;
+
+        // Automatisch den ersten Marker setzen
+        $this->mark('init', PerformanceCategory::SYSTEM);
+    }
+
+    /**
+     * Setzt einen Marker mit einem Label und einer Kategorie
+     */
+    public function mark(string $label, PerformanceCategory $category = PerformanceCategory::CUSTOM): void
+    {
+        if (!$this->enabled) {
+            return;
+        }
+
+        $this->markers[$label] = new PerformanceMarker($label, $category);
+    }
+
+    /**
+     * Startet eine Zeitmessung für einen bestimmten Prozess
+     */
+    public function startMeasure(string $label, PerformanceCategory $category = PerformanceCategory::CUSTOM): void
+    {
+        if (!$this->enabled) {
+            return;
+        }
+
+        $this->activeMeasurements[$label] = new PerformanceMeasurement($label, $category);
+    }
+
+    /**
+     * Beendet eine Zeitmessung und speichert das Ergebnis
+     */
+    public function endMeasure(string $label): void
+    {
+        if (!$this->enabled || !isset($this->activeMeasurements[$label])) {
+            return;
+        }
+
+        $measurement = $this->activeMeasurements[$label];
+        $measurement->end();
+
+        $category = $measurement->getCategory()->value;
+
+        if (!isset($this->completedMeasurements[$category])) {
+            $this->completedMeasurements[$category] = [];
+        }
+
+        $this->completedMeasurements[$category][] = $measurement;
+
+        // Aktive Messung entfernen
+        unset($this->activeMeasurements[$label]);
+
+        // Marker zur einfachen zeitlichen Einordnung setzen
+        $this->mark("{$label}_end", $measurement->getCategory());
+    }
+
+    /**
+     * Führt eine Funktion aus und misst deren Performance
+     */
+    public function measure(
+        string $label,
+        callable $callback,
+        PerformanceCategory $category = PerformanceCategory::CUSTOM
+    ): mixed {
+        if (!$this->enabled) {
+            return $callback();
+        }
+
+        $this->startMeasure($label, $category);
+        $result = $callback();
+        $this->endMeasure($label);
+
+        return $result;
+    }
+
+    /**
+     * Gibt die Zeit zwischen zwei Markern zurück
+     */
+    public function getTimeBetween(string $startLabel, string $endLabel): float
+    {
+        if (!isset($this->markers[$startLabel]) || !isset($this->markers[$endLabel])) {
+            return 0.0;
+        }
+
+        return ($this->markers[$endLabel]->getTime() - $this->markers[$startLabel]->getTime()) * 1000;
+    }
+
+    /**
+     * Gibt den Speicherverbrauch zwischen zwei Markern zurück
+     */
+    public function getMemoryBetween(string $startLabel, string $endLabel): float
+    {
+        if (!isset($this->markers[$startLabel]) || !isset($this->markers[$endLabel])) {
+            return 0.0;
+        }
+
+        return ($this->markers[$endLabel]->getMemory() - $this->markers[$startLabel]->getMemory()) / 1024 / 1024;
+    }
+
+    /**
+     * Gibt alle Marker zurück, gefiltert nach Kategorie
+     */
+    public function getMarkers(?PerformanceCategory $category = null): array
+    {
+        if ($category === null) {
+            return $this->markers;
+        }
+
+        return array_filter(
+            $this->markers,
+            fn (PerformanceMarker $marker): bool => $marker->getCategory() === $category
+        );
+    }
+
+    /**
+     * Gibt einen Bericht über alle Marker aus
+     */
+    public function generateReport(): array
+    {
+        $report = [
+            'summary' => [
+                'total_time_ms' => $this->getTotalTime(),
+                'total_memory_mb' => $this->getTotalMemory(),
+                'marker_count' => count($this->markers),
+            ],
+            'markers' => [],
+            'measurements' => [],
+            'categories' => [],
+        ];
+
+        // Marker chronologisch sortieren
+        $sortedMarkers = $this->markers;
+        uasort($sortedMarkers, fn($a, $b) => $a->getTime() <=> $b->getTime());
+
+        // Marker-Bericht erstellen
+        $previousTime = $this->initTime;
+        foreach ($sortedMarkers as $label => $marker) {
+            $timeSinceStart = ($marker->getTime() - $this->initTime) * 1000;
+            $timeSincePrevious = ($marker->getTime() - $previousTime) * 1000;
+            $memorySinceStart = ($marker->getMemory() - $this->initMemory) / 1024 / 1024;
+
+            $report['markers'][$label] = [
+                'category' => $marker->getCategory()->value,
+                'time_since_start_ms' => round($timeSinceStart, 2),
+                'time_since_previous_ms' => round($timeSincePrevious, 2),
+                'memory_mb' => round($memorySinceStart, 2),
+            ];
+
+            $previousTime = $marker->getTime();
+        }
+
+        // Messungen nach Kategorien zusammenfassen
+        foreach ($this->completedMeasurements as $categoryKey => $measurements) {
+            $report['categories'][$categoryKey] = [
+                'count' => count($measurements),
+                'measurements' => [],
+            ];
+
+            foreach ($measurements as $measurement) {
+                $label = $measurement->getLabel();
+
+                if (!isset($report['measurements'][$label])) {
+                    $report['measurements'][$label] = [
+                        'category' => $measurement->getCategory()->value,
+                        'count' => 0,
+                        'total_time_ms' => 0,
+                        'total_memory_mb' => 0,
+                        'avg_time_ms' => 0,
+                        'avg_memory_mb' => 0,
+                        'min_time_ms' => PHP_FLOAT_MAX,
+                        'max_time_ms' => 0,
+                    ];
+                }
+
+                $duration = $measurement->getDurationMs();
+                $memory = $measurement->getMemoryUsageMb();
+
+                $data = &$report['measurements'][$label];
+                $data['count']++;
+                $data['total_time_ms'] += $duration;
+                $data['total_memory_mb'] += $memory;
+                $data['min_time_ms'] = min($data['min_time_ms'], $duration);
+                $data['max_time_ms'] = max($data['max_time_ms'], $duration);
+                $data['avg_time_ms'] = $data['total_time_ms'] / $data['count'];
+                $data['avg_memory_mb'] = $data['total_memory_mb'] / $data['count'];
+
+                // Einzelmessungen pro Kategorie
+                $report['categories'][$categoryKey]['measurements'][] = [
+                    'label' => $label,
+                    'time_ms' => round($duration, 2),
+                    'memory_mb' => round($memory, 2),
+                    'start_time' => ($measurement->getStartTime() - $this->initTime) * 1000,
+                    'end_time' => ($measurement->getEndTime() - $this->initTime) * 1000,
+                ];
+            }
+
+            // Statistiken für die Kategorie berechnen
+            $categoryMeasurements = $report['categories'][$categoryKey]['measurements'];
+            if (!empty($categoryMeasurements)) {
+                $totalTime = array_sum(array_column($categoryMeasurements, 'time_ms'));
+                $totalMemory = array_sum(array_column($categoryMeasurements, 'memory_mb'));
+                $count = count($categoryMeasurements);
+
+                $report['categories'][$categoryKey]['total_time_ms'] = $totalTime;
+                $report['categories'][$categoryKey]['avg_time_ms'] = $totalTime / $count;
+                $report['categories'][$categoryKey]['total_memory_mb'] = $totalMemory;
+                $report['categories'][$categoryKey]['avg_memory_mb'] = $totalMemory / $count;
+            }
+        }
+
+        // Rundungen für alle numerischen Werte
+        foreach ($report['measurements'] as &$measurement) {
+            $measurement['avg_time_ms'] = round($measurement['avg_time_ms'], 2);
+            $measurement['avg_memory_mb'] = round($measurement['avg_memory_mb'], 2);
+            $measurement['total_time_ms'] = round($measurement['total_time_ms'], 2);
+            $measurement['total_memory_mb'] = round($measurement['total_memory_mb'], 2);
+            $measurement['min_time_ms'] = round($measurement['min_time_ms'], 2);
+            $measurement['max_time_ms'] = round($measurement['max_time_ms'], 2);
+        }
+
+        return $report;
+    }
+
+    /**
+     * Formatiert einen Bericht als HTML
+     */
+    public function generateHtmlReport(): string
+    {
+        $report = $this->generateReport();
+
+        $html = '<div style="font-family: monospace; font-size: 13px; background: #f5f5f5; padding: 10px; border: 1px solid #ddd;">';
+        $html .= '<h3>Performance-Bericht</h3>';
+        $html .= '<p>';
+        $html .= sprintf('Gesamtzeit: <strong>%.2f ms</strong><br>', $report['summary']['total_time_ms']);
+        $html .= sprintf('Speicherverbrauch: <strong>%.2f MB</strong><br>', $report['summary']['total_memory_mb']);
+        $html .= sprintf('Anzahl Marker: <strong>%d</strong>', $report['summary']['marker_count']);
+        $html .= '</p>';
+
+        if (!empty($report['measurements'])) {
+            $html .= '<h4>Messungen</h4>';
+            $html .= '<table style="border-collapse: collapse; width: 100%;">';
+            $html .= '<tr style="background: #eee;"><th style="text-align: left; padding: 5px;">Label</th><th style="text-align: left; padding: 5px;">Kategorie</th><th style="text-align: right; padding: 5px;">Anzahl</th><th style="text-align: right; padding: 5px;">Avg. Zeit (ms)</th><th style="text-align: right; padding: 5px;">Min/Max (ms)</th><th style="text-align: right; padding: 5px;">Avg. Speicher (MB)</th></tr>';
+
+            foreach ($report['measurements'] as $label => $data) {
+                $html .= sprintf(
+                    '<tr style="border-bottom: 1px solid #ddd;"><td style="padding: 5px;">%s</td><td style="padding: 5px;">%s</td><td style="text-align: right; padding: 5px;">%d</td><td style="text-align: right; padding: 5px;">%.2f</td><td style="text-align: right; padding: 5px;">%.2f / %.2f</td><td style="text-align: right; padding: 5px;">%.2f</td></tr>',
+                    htmlspecialchars($label),
+                    htmlspecialchars($data['category']),
+                    $data['count'],
+                    $data['avg_time_ms'],
+                    $data['min_time_ms'],
+                    $data['max_time_ms'],
+                    $data['avg_memory_mb']
+                );
+            }
+
+            $html .= '</table>';
+        }
+
+        $html .= '<h4>Marker-Zeitleiste</h4>';
+        $html .= '<table style="border-collapse: collapse; width: 100%;">';
+        $html .= '<tr style="background: #eee;"><th style="text-align: left; padding: 5px;">Zeit (ms)</th><th style="text-align: left; padding: 5px;">Label</th><th style="text-align: left; padding: 5px;">Kategorie</th><th style="text-align: right; padding: 5px;">+Zeit (ms)</th><th style="text-align: right; padding: 5px;">Speicher (MB)</th></tr>';
+
+        foreach ($report['markers'] as $label => $data) {
+            $html .= sprintf(
+                '<tr style="border-bottom: 1px solid #ddd;"><td style="padding: 5px;">%.2f</td><td style="padding: 5px;">%s</td><td style="padding: 5px;">%s</td><td style="text-align: right; padding: 5px;">%.2f</td><td style="text-align: right; padding: 5px;">%.2f</td></tr>',
+                $data['time_since_start_ms'],
+                htmlspecialchars($label),
+                htmlspecialchars($data['category']),
+                $data['time_since_previous_ms'],
+                $data['memory_mb']
+            );
+        }
+
+        $html .= '</table>';
+
+        // Kategorieübersicht
+        if (!empty($report['categories'])) {
+            $html .= '<h4>Kategorien</h4>';
+            $html .= '<table style="border-collapse: collapse; width: 100%;">';
+            $html .= '<tr style="background: #eee;"><th style="text-align: left; padding: 5px;">Kategorie</th><th style="text-align: right; padding: 5px;">Anzahl</th><th style="text-align: right; padding: 5px;">Gesamtzeit (ms)</th><th style="text-align: right; padding: 5px;">Durchschnitt (ms)</th></tr>';
+
+            foreach ($report['categories'] as $category => $data) {
+                if (isset($data['total_time_ms'])) {
+                    $html .= sprintf(
+                        '<tr style="border-bottom: 1px solid #ddd;"><td style="padding: 5px;">%s</td><td style="text-align: right; padding: 5px;">%d</td><td style="text-align: right; padding: 5px;">%.2f</td><td style="text-align: right; padding: 5px;">%.2f</td></tr>',
+                        htmlspecialchars($category),
+                        $data['count'],
+                        $data['total_time_ms'],
+                        $data['avg_time_ms']
+                    );
+                }
+            }
+
+            $html .= '</table>';
+        }
+
+        $html .= '</div>';
+
+        return $html;
+    }
+
+    /**
+     * Gibt einen Bericht als Text aus
+     */
+    public function generateTextReport(): string
+    {
+        $report = $this->generateReport();
+
+        $text = "== Performance-Bericht ==\n";
+        $text .= sprintf("Gesamtzeit: %.2f ms\n", $report['summary']['total_time_ms']);
+        $text .= sprintf("Speicherverbrauch: %.2f MB\n", $report['summary']['total_memory_mb']);
+        $text .= sprintf("Anzahl Marker: %d\n\n", $report['summary']['marker_count']);
+
+        if (!empty($report['measurements'])) {
+            $text .= "== Messungen ==\n";
+            $text .= sprintf("%-30s %-15s %10s %15s %15s %15s\n",
+                "Label", "Kategorie", "Anzahl", "Avg. Zeit (ms)", "Min/Max (ms)", "Avg. Speicher (MB)");
+            $text .= str_repeat("-", 100) . "\n";
+
+            foreach ($report['measurements'] as $label => $data) {
+                $text .= sprintf(
+                    "%-30s %-15s %10d %15.2f %15s %15.2f\n",
+                    $label,
+                    $data['category'],
+                    $data['count'],
+                    $data['avg_time_ms'],
+                    sprintf("%.2f/%.2f", $data['min_time_ms'], $data['max_time_ms']),
+                    $data['avg_memory_mb']
+                );
+            }
+
+            $text .= "\n";
+        }
+
+        $text .= "== Marker-Zeitleiste ==\n";
+        $text .= sprintf("%-10s %-30s %-15s %15s %15s\n",
+            "Zeit (ms)", "Label", "Kategorie", "+Zeit (ms)", "Speicher (MB)");
+        $text .= str_repeat("-", 90) . "\n";
+
+        foreach ($report['markers'] as $label => $data) {
+            $text .= sprintf(
+                "%-10.2f %-30s %-15s %15.2f %15.2f\n",
+                $data['time_since_start_ms'],
+                $label,
+                $data['category'],
+                $data['time_since_previous_ms'],
+                $data['memory_mb']
+            );
+        }
+
+        if (!empty($report['categories'])) {
+            $text .= "\n== Kategorien ==\n";
+            $text .= sprintf("%-15s %10s %20s %20s\n",
+                "Kategorie", "Anzahl", "Gesamtzeit (ms)", "Durchschnitt (ms)");
+            $text .= str_repeat("-", 70) . "\n";
+
+            foreach ($report['categories'] as $category => $data) {
+                if (isset($data['total_time_ms'])) {
+                    $text .= sprintf(
+                        "%-15s %10d %20.2f %20.2f\n",
+                        $category,
+                        $data['count'],
+                        $data['total_time_ms'],
+                        $data['avg_time_ms']
+                    );
+                }
+            }
+        }
+
+        return $text;
+    }
+
+    /**
+     * Gibt die Gesamtausführungszeit zurück
+     */
+    public function getTotalTime(): float
+    {
+        return (microtime(true) - $this->initTime) * 1000; // in ms
+    }
+
+    /**
+     * Gibt den Gesamtspeicherverbrauch zurück
+     */
+    public function getTotalMemory(): float
+    {
+        return (memory_get_usage() - $this->initMemory) / 1024 / 1024; // in MB
+    }
+
+    /**
+     * Aktiviert oder deaktiviert den PerformanceMeter
+     */
+    public function setEnabled(bool $enabled): void
+    {
+        $this->enabled = $enabled;
+    }
+
+    /**
+     * Gibt zurück, ob der PerformanceMeter aktiviert ist
+     */
+    public function isEnabled(): bool
+    {
+        return $this->enabled;
+    }
+
+    /**
+     * Setzt alle Messungen zurück
+     */
+    public function reset(): void
+    {
+        $this->markers = [];
+        $this->activeMeasurements = [];
+        $this->completedMeasurements = [];
+        $this->initTime = microtime(true);
+        $this->initMemory = memory_get_usage();
+
+        // Automatisch den ersten Marker setzen
+        $this->mark('init', PerformanceCategory::SYSTEM);
+    }
+}
diff --git a/src/Framework/Performance/PerformanceMetricLogger.php b/src/Framework/Performance/PerformanceMetricLogger.php
new file mode 100644
index 00000000..5da98fdf
--- /dev/null
+++ b/src/Framework/Performance/PerformanceMetricLogger.php
@@ -0,0 +1,189 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Performance;
+
+use App\Framework\DateTime\Clock;
+
+class PerformanceMetricLogger
+{
+    private \Redis $redis;
+    private Clock $clock;
+    private array $config;
+
+    public function __construct(\Redis $redis, Clock $clock, array $config = [])
+    {
+        $this->redis = $redis;
+        $this->clock = $clock;
+        $this->config = array_merge([
+            'enabled' => true,
+            'ttl_minutes' => 60,
+            'slow_threshold_ms' => 100,
+            'max_slow_endpoints' => 100,
+            'max_popular_endpoints' => 100,
+        ], $config);
+    }
+
+    public function log(PerformanceMeter $meter, array $context = []): void
+    {
+        if (!$this->config['enabled']) {
+            return;
+        }
+
+        $report = $meter->generateReport();
+        $totalTime = $report['summary']['total_time_ms'];
+        $url = $_SERVER['REQUEST_URI'] ?? 'cli';
+        $method = $_SERVER['REQUEST_METHOD'] ?? 'CLI';
+
+        try {
+            $this->updateLiveMetrics($url, $method, $totalTime, $report, $context);
+        } catch (\Exception $e) {
+            // Redis-Fehler sollten nicht den Request crashen lassen
+            error_log("Redis metrics update failed: " . $e->getMessage());
+        }
+    }
+
+    private function updateLiveMetrics(string $url, string $method, float $duration, array $report, array $context): void
+    {
+        $now = $this->clock->now();
+        $minute = $now->format('Y-m-d H:i');
+        $hour = $now->format('Y-m-d H');
+        $ttl = $this->config['ttl_minutes'] * 60;
+
+        // Pipeline für bessere Performance
+        $pipe = $this->redis->pipeline();
+
+        // Requests pro Minute/Stunde
+        $pipe->incr("performance:requests_per_minute:$minute");
+        $pipe->expire("performance:requests_per_minute:$minute", $ttl);
+
+        $pipe->incr("performance:requests_per_hour:$hour");
+        $pipe->expire("performance:requests_per_hour:$hour", $ttl * 24);
+
+        // Response-Zeiten sammeln
+        $pipe->lpush("performance:response_times:$minute", $duration);
+        $pipe->ltrim("performance:response_times:$minute", 0, 999); // Max 1000 Werte
+        $pipe->expire("performance:response_times:$minute", $ttl);
+
+        // Speicherverbrauch
+        $memoryMb = $report['summary']['total_memory_mb'];
+        $pipe->lpush("performance:memory_usage:$minute", $memoryMb);
+        $pipe->ltrim("performance:memory_usage:$minute", 0, 999);
+        $pipe->expire("performance:memory_usage:$minute", $ttl);
+
+        // Langsame Endpoints tracken
+        if ($duration > $this->config['slow_threshold_ms']) {
+            $endpoint = "$method $url";
+            $pipe->zadd('performance:slow_endpoints', $duration, $endpoint);
+            $pipe->zremrangebyrank('performance:slow_endpoints', 0, -($this->config['max_slow_endpoints'] + 1));
+        }
+
+        // Populäre Endpoints
+        $endpoint = "$method $url";
+        $pipe->zincrby('performance:popular_endpoints', 1, $endpoint);
+        $pipe->zremrangebyrank('performance:popular_endpoints', 0, -($this->config['max_popular_endpoints'] + 1));
+
+        // Kategorien-Statistiken
+        foreach ($report['categories'] ?? [] as $category => $data) {
+            if (isset($data['total_time_ms'])) {
+                $pipe->lpush("performance:category:$category:$minute", $data['total_time_ms']);
+                $pipe->ltrim("performance:category:$category:$minute", 0, 99);
+                $pipe->expire("performance:category:$category:$minute", $ttl);
+            }
+        }
+
+        // Error-Rate tracking
+        if (isset($context['has_errors']) && $context['has_errors']) {
+            $pipe->incr("performance:errors_per_minute:$minute");
+            $pipe->expire("performance:errors_per_minute:$minute", $ttl);
+        }
+
+        $pipe->exec();
+    }
+
+    public function getLiveMetrics(): array
+    {
+        try {
+            $now = $this->clock->now();
+            $minute = $now->format('Y-m-d H:i');
+            $prevMinute = $now->modify('-1 minute')->format('Y-m-d H:i');
+            $hour = $now->format('Y-m-d H');
+
+            return [
+                'requests' => [
+                    'current_minute' => (int) ($this->redis->get("performance:requests_per_minute:$minute") ?? 0),
+                    'previous_minute' => (int) ($this->redis->get("performance:requests_per_minute:$prevMinute") ?? 0),
+                    'current_hour' => (int) ($this->redis->get("performance:requests_per_hour:$hour") ?? 0),
+                ],
+                'response_times' => [
+                    'current_avg_ms' => $this->calculateAverage("performance:response_times:$minute"),
+                    'previous_avg_ms' => $this->calculateAverage("performance:response_times:$prevMinute"),
+                ],
+                'memory' => [
+                    'current_avg_mb' => $this->calculateAverage("performance:memory_usage:$minute"),
+                    'previous_avg_mb' => $this->calculateAverage("performance:memory_usage:$prevMinute"),
+                ],
+                'slowest_endpoints' => $this->redis->zrevrange('performance:slow_endpoints', 0, 9, true),
+                'popular_endpoints' => $this->redis->zrevrange('performance:popular_endpoints', 0, 9, true),
+                'error_rate' => [
+                    'current_minute' => (int) ($this->redis->get("performance:errors_per_minute:$minute") ?? 0),
+                    'previous_minute' => (int) ($this->redis->get("performance:errors_per_minute:$prevMinute") ?? 0),
+                ],
+                'categories' => $this->getCategoryMetrics($minute, $prevMinute),
+            ];
+
+        } catch (\Exception $e) {
+            return ['error' => $e->getMessage()];
+        }
+    }
+
+    private function calculateAverage(string $key): float
+    {
+        $values = $this->redis->lrange($key, 0, -1);
+        if (empty($values)) {
+            return 0.0;
+        }
+
+        $sum = array_sum(array_map('floatval', $values));
+        return round($sum / count($values), 2);
+    }
+
+    private function getCategoryMetrics(string $minute, string $prevMinute): array
+    {
+        $categories = [];
+        $keys = $this->redis->keys("performance:category:*:$minute");
+
+        foreach ($keys as $key) {
+            if (preg_match('/performance:category:([^:]+):/', $key, $matches)) {
+                $category = $matches[1];
+                $prevKey = "performance:category:$category:$prevMinute";
+
+                $categories[$category] = [
+                    'current_avg_ms' => $this->calculateAverage($key),
+                    'previous_avg_ms' => $this->calculateAverage($prevKey),
+                ];
+            }
+        }
+
+        return $categories;
+    }
+
+    public function clearMetrics(): void
+    {
+        $keys = $this->redis->keys('performance:*');
+        if (!empty($keys)) {
+            $this->redis->del($keys);
+        }
+    }
+
+    public function setEnabled(bool $enabled): void
+    {
+        $this->config['enabled'] = $enabled;
+    }
+
+    public function isEnabled(): bool
+    {
+        return $this->config['enabled'];
+    }
+}
diff --git a/src/Framework/Performance/PerformanceMiddleware.php b/src/Framework/Performance/PerformanceMiddleware.php
new file mode 100644
index 00000000..885b6d3d
--- /dev/null
+++ b/src/Framework/Performance/PerformanceMiddleware.php
@@ -0,0 +1,80 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Performance;
+
+use App\Framework\Http\HttpMiddleware;
+use App\Framework\Http\MiddlewareContext;
+use App\Framework\Http\Response;
+use App\Framework\Config\Configuration;
+use App\Framework\Http\ResponseManipulator;
+
+readonly class PerformanceMiddleware implements XHttpMiddleware
+{
+    public function __construct(
+        private PerformanceMeter $performanceMeter,
+        private Configuration    $config
+    ) {}
+
+    public function __invoke(MiddlewareContext $context, callable $next): MiddlewareContext
+    {
+        $request = $context->request;
+        // Marker für Anfrage-Start setzen
+        $this->performanceMeter->mark('request_start', PerformanceCategory::SYSTEM);
+
+        // Messung für Anfrageverarbeitung starten
+        $this->performanceMeter->startMeasure('request_processing', PerformanceCategory::SYSTEM);
+
+        // Anfrage weiterleiten
+        $response = $next($request);
+
+        // Messung beenden
+        $this->performanceMeter->endMeasure('request_processing');
+        $this->performanceMeter->mark('request_end', PerformanceCategory::SYSTEM);
+
+        // Performance-Bericht hinzufügen, wenn Debug-Modus aktiv
+        if ($this->config->get('debug', false) && !$request->isAjax()) {
+            // Nur für HTML-Antworten
+            $contentType = $response->headers->get('Content-Type', '');
+            if (str_contains($contentType, 'text/html') || empty($contentType)) {
+                $this->appendPerformanceReport($response);
+            } else {
+                $this->addPerformanceHeaders($response);
+            }
+        } elseif ($this->config->get('debug', false) && $request->isAjax()) {
+            // Für AJAX-Anfragen Header hinzufügen
+            $this->addPerformanceHeaders($response);
+        }
+
+        return $response;
+    }
+
+    private function appendPerformanceReport(Response $response): void
+    {
+        $body = $response->body;
+
+        // Suchen nach dem schließenden </body> Tag
+        $closingBodyPos = strripos($body, '</body>');
+
+        if ($closingBodyPos !== false) {
+            $report = $this->performanceMeter->generateHtmlReport();
+
+            // Report vor dem schließenden </body> Tag einfügen
+            $newBody = substr($body, 0, $closingBodyPos);
+            $newBody .= $report;
+            $newBody .= substr($body, $closingBodyPos);
+
+            $response = new ResponseManipulator()->withBody($response, $newBody);
+            //$response->setBody($newBody);
+        }
+    }
+
+    private function addPerformanceHeaders(Response $response): void
+    {
+        $report = $this->performanceMeter->generateReport();
+
+        $response->headers->set('X-Performance-Time', sprintf('%.2f ms', $report['summary']['total_time_ms']));
+        $response->headers->set('X-Performance-Memory', sprintf('%.2f MB', $report['summary']['total_memory_mb']));
+    }
+}
diff --git a/src/Framework/Performance/README.md b/src/Framework/Performance/README.md
new file mode 100644
index 00000000..8486b9cc
--- /dev/null
+++ b/src/Framework/Performance/README.md
@@ -0,0 +1,14 @@
+# Performance Monitoring Framework
+
+Ein umfassendes Performance-Monitoring-System für PHP-Anwendungen mit File-Logging, Redis-Metriken und Database-Persistierung.
+
+## Features
+
+- 🚀 **Minimaler Overhead** - Optimiert für Production-Einsatz
+- 📊 **Live-Metriken** - Real-time Monitoring via Redis
+- 💾 **Asynchrone Persistierung** - Background-Jobs für Database-Storage
+- 🔍 **Detaillierte Berichte** - Kategorisierte Performance-Analyse
+- 🛠️ **Flexible Integration** - Middleware, Event Handler, Manual Usage
+- 📈 **Skalierbar** - Buffer-System und Batch-Processing
+
+## Architektur
diff --git a/src/Framework/QueryBus/DefaultQueryBus.php b/src/Framework/QueryBus/DefaultQueryBus.php
new file mode 100644
index 00000000..86fd09ae
--- /dev/null
+++ b/src/Framework/QueryBus/DefaultQueryBus.php
@@ -0,0 +1,48 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\QueryBus;
+
+use App\Framework\DI\DefaultContainer;
+
+final readonly class DefaultQueryBus implements QueryBus
+{
+    public function __construct(
+        private array     $eventHandlers,
+        private DefaultContainer $container
+    ) {}
+
+    /**
+     * Dispatcht ein Event an alle registrierten Handler
+     *
+     * @param object $event Das zu dispatchende Event
+     * @return void
+     */
+    public function dispatch(object $event): mixed {
+        $eventClass = get_class($event);
+
+        // Prüfe, ob Handler für diesen Event-Typ registriert sind
+        if (empty($this->eventHandlers) || !isset($this->eventHandlers[$eventClass])) {
+            return null;
+        }
+
+        // Führe alle Handler für diesen Event-Typ aus
+        foreach ($this->eventHandlers[$eventClass] as $handler) {
+            try {
+                $handlerClass = $this->container->get($handler['class']);
+                $method = $handler['method'];
+
+                return $handlerClass->$method($event);
+
+                // Stoppe die Propagation, wenn der Handler dies anfordert
+                if (isset($handler['stopPropagation']) && $handler['stopPropagation']) {
+                    break;
+                }
+            } catch (\Throwable $e) {
+                // Fehler in Event-Handlern sollten die Anwendung nicht abstürzen lassen
+                // In einer echten Anwendung würde hier ein Logger verwendet
+                error_log('Fehler bei der Ausführung des Event-Handlers: ' . $e->getMessage());
+            }
+        }
+    }
+}
diff --git a/src/Framework/QueryBus/QueryBus.php b/src/Framework/QueryBus/QueryBus.php
new file mode 100644
index 00000000..4edc6b2d
--- /dev/null
+++ b/src/Framework/QueryBus/QueryBus.php
@@ -0,0 +1,8 @@
+<?php
+
+namespace App\Framework\QueryBus;
+
+interface QueryBus
+{
+    public function dispatch(object $event): mixed;
+}
diff --git a/src/Framework/QueryBus/QueryBusInitializer.php b/src/Framework/QueryBus/QueryBusInitializer.php
new file mode 100644
index 00000000..b5121ca9
--- /dev/null
+++ b/src/Framework/QueryBus/QueryBusInitializer.php
@@ -0,0 +1,23 @@
+<?php
+
+namespace App\Framework\QueryBus;
+
+use App\Framework\DI\Container;
+use App\Framework\DI\Initializer;
+use App\Framework\Discovery\Results\DiscoveryResults;
+
+final readonly class QueryBusInitializer
+{
+    public function __construct(
+        private Container        $container,
+        private DiscoveryResults $results
+    ){}
+
+    #[Initializer]
+    public function __invoke(): QueryBus
+    {
+        $handlers = $this->results->get(QueryHandler::class);
+
+        return new DefaultQueryBus($handlers, $this->container);
+    }
+}
diff --git a/src/Framework/QueryBus/QueryHandler.php b/src/Framework/QueryBus/QueryHandler.php
new file mode 100644
index 00000000..f0fa2d1f
--- /dev/null
+++ b/src/Framework/QueryBus/QueryHandler.php
@@ -0,0 +1,24 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\QueryBus;
+
+/**
+ * Attribut, das eine Methode als Event-Handler kennzeichnet.
+ *
+ * Beispiel:
+ * #[EventHandler]
+ * public function handleUserRegistered(UserRegistered $event): void { ... }
+ */
+#[\Attribute(\Attribute::TARGET_METHOD)]
+final readonly class QueryHandler
+{
+    /**
+     * @param int|null $priority Priorität des Handlers (höhere Werte werden zuerst ausgeführt)
+     * @param bool $stopPropagation Gibt an, ob die Event-Propagation nach diesem Handler gestoppt werden soll
+     */
+    public function __construct(
+        public ?int $priority = null,
+        public bool $stopPropagation = false
+    ) {}
+}
diff --git a/src/Framework/QueryBus/QueryHandlerCompiler.php b/src/Framework/QueryBus/QueryHandlerCompiler.php
new file mode 100644
index 00000000..cfdb947b
--- /dev/null
+++ b/src/Framework/QueryBus/QueryHandlerCompiler.php
@@ -0,0 +1,71 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\QueryBus;
+
+use App\Framework\Core\AttributeCompiler;
+use App\Framework\QueryBus\QueryHandler;
+
+/**
+ * Compiler für Event-Handler
+ */
+final readonly class QueryHandlerCompiler implements AttributeCompiler
+{
+    /**
+     * Gibt die Attributklasse zurück, die dieser Compiler verarbeitet
+     */
+    public function getAttributeClass(): string
+    {
+        return QueryHandler::class;
+    }
+
+    /**
+     * Kompiliert die Event-Handler
+     *
+     * @param array $handlers Array mit Attributdaten aus dem Mapper
+     * @return array Kompilierte Event-Handler
+     */
+    public function compile(array $handlers): array
+    {
+        $compiledHandlers = [];
+
+        // Wenn keine Handler vorhanden sind, leeres Array zurückgeben
+        if (empty($handlers)) {
+            return $compiledHandlers;
+        }
+
+        foreach ($handlers as $handler) {
+            $className = $handler['class'] ?? null;
+            $methodName = $handler['method'] ?? null;
+            $eventClass = $handler['event_class'] ?? null;
+            $priority = $handler['attribute_data']['priority'] ?? 0;
+            $stopPropagation = $handler['attribute_data']['stopPropagation'] ?? false;
+
+            // Prüfe, ob alle erforderlichen Daten vorhanden sind
+            if (!$className || !$methodName || !$eventClass) {
+                continue;
+            }
+
+            // Füge den Handler zur Liste der Handler für diesen Event-Typ hinzu
+            if (!isset($compiledHandlers[$eventClass])) {
+                $compiledHandlers[$eventClass] = [];
+            }
+
+            $compiledHandlers[$eventClass][] = [
+                'class' => $className,
+                'method' => $methodName,
+                'priority' => $priority,
+                'stopPropagation' => $stopPropagation
+            ];
+        }
+
+        // Sortiere die Handler nach Priorität für jeden Event-Typ
+        foreach ($compiledHandlers as $eventClass => $eventHandlers) {
+            usort($compiledHandlers[$eventClass], function ($a, $b) {
+                return $b['priority'] <=> $a['priority'];
+            });
+        }
+
+        return $compiledHandlers;
+    }
+}
diff --git a/src/Framework/QueryBus/QueryHandlerMapper.php b/src/Framework/QueryBus/QueryHandlerMapper.php
new file mode 100644
index 00000000..5cdb7e4d
--- /dev/null
+++ b/src/Framework/QueryBus/QueryHandlerMapper.php
@@ -0,0 +1,60 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\QueryBus;
+
+use App\Framework\Core\AttributeMapper;
+use ReflectionClass;
+use ReflectionMethod;
+
+/**
+ * Mapper für das EventHandler-Attribut
+ */
+final class QueryHandlerMapper implements AttributeMapper
+{
+    /**
+     * Gibt die Attributklasse zurück, die dieser Mapper verarbeitet
+     */
+    public function getAttributeClass(): string
+    {
+        return QueryHandler::class;
+    }
+
+    /**
+     * Implementiert die map-Methode aus dem AttributeMapper-Interface
+     *
+     * @param object $reflectionTarget Das Reflektionsobjekt (ReflectionClass|ReflectionMethod)
+     * @param object $attributeInstance Die Attributinstanz
+     * @return array|null Die Attributdaten oder null, wenn nicht verarbeitet werden kann
+     */
+    public function map(object $reflectionTarget, object $attributeInstance): ?array
+    {
+        if (!($reflectionTarget instanceof ReflectionMethod)) {
+            return null;
+        }
+
+        $parameters = $reflectionTarget->getParameters();
+
+        // Event-Handler müssen mindestens einen Parameter haben (das Event)
+        if (count($parameters) < 1) {
+            return null;
+        }
+
+        $eventType = $parameters[0]->getType();
+        if (!$eventType || $eventType->isBuiltin()) {
+            return null;
+        }
+
+        $eventClassName = $eventType->getName();
+
+        return [
+            'class' => $reflectionTarget->getDeclaringClass()->getName(),
+            'method' => $reflectionTarget->getName(),
+            'event_class' => $eventClassName,
+            'attribute_data' => [
+                'priority' => $attributeInstance->priority ?? 0,
+                'stopPropagation' => $attributeInstance->stopPropagation ?? false
+            ],
+        ];
+    }
+}
diff --git a/src/Framework/Queue/FileQueue.php b/src/Framework/Queue/FileQueue.php
new file mode 100644
index 00000000..7366987c
--- /dev/null
+++ b/src/Framework/Queue/FileQueue.php
@@ -0,0 +1,129 @@
+<?php
+
+namespace App\Framework\Queue;
+
+use App\Framework\Cache\Serializer;
+use App\Framework\Cache\Serializer\PhpSerializer;
+
+final readonly class FileQueue implements Queue
+{
+    private string $queueDir;
+
+    public function __construct(
+        string $queueDir,
+        private Serializer $serializer = new PhpSerializer())
+    {
+        $this->queueDir = $queueDir;
+        if (!is_dir($queueDir)) {
+            mkdir($queueDir, 0777, true);
+        }
+    }
+
+    public function push(object $job): void
+    {
+        // Job-Hash für Deduplication
+        $jobHash = md5($this->serializer->serialize($job));
+        $hashFile = $this->queueDir . '/hash_' . $jobHash . '.job';
+
+        // DETAILED DEBUG: Wer ruft push() auf?
+        $trace = debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS, 10);
+        $caller = '';
+        foreach ($trace as $frame) {
+            if (isset($frame['file']) && isset($frame['line'])) {
+                $caller .= basename($frame['file']) . ':' . $frame['line'] . ' -> ';
+            }
+        }
+
+        error_log("FileQueue Debug: PUSH called from: " . $caller);
+        error_log("FileQueue Debug: Job class: " . get_class($job));
+        error_log("FileQueue Debug: Job data: " . json_encode($job));
+        error_log("FileQueue Debug: Job hash: " . $jobHash);
+
+        // Prüfe ob identischer Job bereits existiert
+        if (file_exists($hashFile)) {
+            error_log("FileQueue Debug: ⚠️  DUPLICATE JOB REJECTED - hash already exists: " . $jobHash);
+            error_log("FileQueue Debug: Called from: " . $caller);
+            return; // Job wird nicht hinzugefügt
+        }
+
+        // Verwende Hash als Dateiname für automatische Deduplication
+        file_put_contents($hashFile, $this->serializer->serialize($job));
+        error_log("FileQueue Debug: ✅ Job added with hash: " . $jobHash);
+    }
+
+    public function pop(): ?object
+    {
+        $files = glob($this->queueDir . '/*.job');
+
+        // Debug: Queue-Status loggen
+        if (empty($files)) {
+            return null;
+        }
+
+        error_log("FileQueue Debug: Found " . count($files) . " job files in " . $this->queueDir);
+        error_log("FileQueue Debug: Files: " . implode(', ', array_map('basename', $files)));
+
+        // Sortiere nach Erstellungsdatum (FIFO)
+        usort($files, function($a, $b) {
+            return filemtime($a) <=> filemtime($b);
+        });
+
+        $file = $files[0];
+        $lockFile = $file . '.lock';
+
+        // Atomic Lock-Mechanismus um race conditions zu verhindern
+        if (file_exists($lockFile)) {
+            error_log("FileQueue Debug: Job file is locked: $file");
+            return null; // Job wird bereits verarbeitet
+        }
+
+        // Lock erstellen
+        if (!@touch($lockFile)) {
+            error_log("FileQueue Debug: Could not create lock file: $lockFile");
+            return null;
+        }
+
+        try {
+            // Prüfe ob Datei noch existiert (race condition)
+            if (!file_exists($file) || !is_readable($file)) {
+                error_log("FileQueue Debug: Job file not accessible: $file");
+                @unlink($lockFile);
+                return $this->pop();
+            }
+
+            $content = file_get_contents($file);
+            if ($content === false) {
+                error_log("FileQueue Debug: Could not read job file: $file");
+                @unlink($file);
+                @unlink($lockFile);
+                return $this->pop();
+            }
+
+            $job = $this->serializer->unserialize($content);
+
+            // Atomic delete: Erst rename, dann delete
+            $tempFile = $file . '.deleting.' . time() . '.' . getmypid();
+            if (rename($file, $tempFile)) {
+                unlink($tempFile);
+                error_log("FileQueue Debug: Successfully deleted job file: " . basename($file));
+            } else {
+                error_log("FileQueue Debug: Failed to rename job file for deletion: $file");
+                // Fallback: direktes löschen versuchen
+                if (!@unlink($file)) {
+                    error_log("FileQueue Debug: Failed to delete job file: $file - moving to processed");
+                    $processedFile = $file . '.processed.' . time();
+                    @rename($file, $processedFile);
+                }
+            }
+
+            @unlink($lockFile);
+            return $job;
+
+        } catch (\Throwable $e) {
+            error_log("FileQueue Debug: Failed to process job from file $file: " . $e->getMessage());
+            @unlink($file);
+            @unlink($lockFile);
+            return $this->pop();
+        }
+    }
+}
diff --git a/src/Framework/Queue/Queue.php b/src/Framework/Queue/Queue.php
new file mode 100644
index 00000000..6468c753
--- /dev/null
+++ b/src/Framework/Queue/Queue.php
@@ -0,0 +1,10 @@
+<?php
+
+namespace App\Framework\Queue;
+
+interface Queue
+{
+    public function push(object $job): void;
+    public function pop(): ?object;
+}
+
diff --git a/src/Framework/Queue/QueueInitializer.php b/src/Framework/Queue/QueueInitializer.php
new file mode 100644
index 00000000..26c5231c
--- /dev/null
+++ b/src/Framework/Queue/QueueInitializer.php
@@ -0,0 +1,29 @@
+<?php
+
+namespace App\Framework\Queue;
+
+use App\Framework\Core\PathProvider;
+use App\Framework\DI\Initializer;
+
+final readonly class QueueInitializer
+{
+    public function __construct(
+        private PathProvider $pathProvider
+    )
+    {
+    }
+    #[Initializer]
+    public function __invoke(): Queue
+    {
+        $queue = new RedisQueue(
+            queueName: 'commands',
+            host: 'redis',
+            port: 6379,
+
+        );
+
+        $path = $this->pathProvider->resolvePath('/src/Framework/CommandBus/storage/queue/');
+
+        return new FileQueue($path);
+    }
+}
diff --git a/src/Framework/Queue/RedisQueue.php b/src/Framework/Queue/RedisQueue.php
new file mode 100644
index 00000000..d15e12c4
--- /dev/null
+++ b/src/Framework/Queue/RedisQueue.php
@@ -0,0 +1,53 @@
+<?php
+
+namespace App\Framework\Queue;
+
+use App\Framework\Cache\Serializer;
+use App\Framework\Cache\Serializer\PhpSerializer;
+use Predis\Client as Redis;
+
+final class RedisQueue implements Queue
+{
+    private Redis $redis;
+    private string $queueName;
+
+    public function __construct(
+        string $queueName = 'commands',
+        string $host = '127.0.0.1',
+        int $port = 6379,
+        ?string $password = null,
+        int $db = 0,
+        private readonly Serializer $serializer = new PhpSerializer
+    ) {
+        $this->queueName = $queueName;
+        $this->redis = new Redis([
+            'scheme' => 'tcp',
+            'host'   => $host,
+            'port'   => $port,
+            'timeout' => 1.0,
+            'read_write_timeout' => 0,
+        ]);
+        $this->redis->connect();
+        if ($password) {
+            $this->redis->auth($password);
+        }
+        $this->redis->select($db);
+    }
+
+    public function push(object $job): void
+    {
+        $data = $this->serializer->serialize($job);
+        $this->redis->rpush($this->queueName, [$data]);
+    }
+
+    public function pop(): ?object
+    {
+        // Wartet bis zu 2 Sekunden auf einen neuen Job (blocking)
+        $result = $this->redis->blpop($this->queueName, 2);
+
+        if ($result && isset($result[1])) {
+            return $this->serializer->unserialize($result[1]);
+        }
+        return null;
+    }
+}
diff --git a/src/Framework/RateLimit/RateLimitResult.php b/src/Framework/RateLimit/RateLimitResult.php
new file mode 100644
index 00000000..57e63fde
--- /dev/null
+++ b/src/Framework/RateLimit/RateLimitResult.php
@@ -0,0 +1,64 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\RateLimit;
+
+readonly class RateLimitResult
+{
+    public function __construct(
+        private bool $allowed,
+        private int $limit,
+        private int $current,
+        private ?int $retryAfter = null
+    ) {}
+
+    public static function allowed(int $limit, int $current): self
+    {
+        return new self(
+            allowed: true,
+            limit: $limit,
+            current: $current
+        );
+    }
+
+    public static function exceeded(int $limit, int $current, int $retryAfter): self
+    {
+        return new self(
+            allowed: false,
+            limit: $limit,
+            current: $current,
+            retryAfter: $retryAfter
+        );
+    }
+
+    public function isAllowed(): bool
+    {
+        return $this->allowed;
+    }
+
+    public function isExceeded(): bool
+    {
+        return !$this->allowed;
+    }
+
+    public function getLimit(): int
+    {
+        return $this->limit;
+    }
+
+    public function getCurrent(): int
+    {
+        return $this->current;
+    }
+
+    public function getRetryAfter(): ?int
+    {
+        return $this->retryAfter;
+    }
+
+    public function getRemainingRequests(): int
+    {
+        return max(0, $this->limit - $this->current);
+    }
+}
diff --git a/src/Framework/RateLimit/RateLimiter.php b/src/Framework/RateLimit/RateLimiter.php
new file mode 100644
index 00000000..4f7d08ec
--- /dev/null
+++ b/src/Framework/RateLimit/RateLimiter.php
@@ -0,0 +1,88 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\RateLimit;
+
+use App\Framework\RateLimit\Storage\StorageInterface;
+use App\Framework\RateLimit\TimeProvider\TimeProviderInterface;
+use App\Framework\RateLimit\TimeProvider\SystemTimeProvider;
+
+final readonly class RateLimiter
+{
+    public function __construct(
+        private StorageInterface $storage,
+        private TimeProviderInterface $timeProvider = new SystemTimeProvider()
+    ) {}
+
+    public function checkLimit(string $key, int $limit, int $window): RateLimitResult
+    {
+        $now = $this->timeProvider->getCurrentTime();
+        $windowStart = $now - $window;
+
+        // Sliding Window Log Implementierung
+        $requests = $this->storage->getRequestsInWindow($key, $windowStart, $now);
+
+        if (count($requests) >= $limit) {
+            $oldestRequest = min($requests);
+            $retryAfter = $oldestRequest + $window - $now;
+
+            return RateLimitResult::exceeded($limit, count($requests), max(1, $retryAfter));
+        }
+
+        // Request hinzufügen
+        $this->storage->addRequest($key, $now, $window);
+
+        return RateLimitResult::allowed($limit, count($requests) + 1);
+    }
+
+    public function checkTokenBucket(string $key, int $capacity, int $refillRate, int $tokens = 1): RateLimitResult
+    {
+        $now = $this->timeProvider->getCurrentTime();
+        $bucket = $this->storage->getTokenBucket($key);
+
+        if ($bucket === null) {
+            $bucket = new TokenBucket($capacity, $capacity, $now);
+        }
+
+        // Token nachfüllen
+        $timePassed = $now - $bucket->lastRefill;
+        $tokensToAdd = min($capacity - $bucket->tokens, intval($timePassed * $refillRate));
+
+        $bucket = new TokenBucket(
+            $bucket->capacity,
+            $bucket->tokens + $tokensToAdd,
+            $now
+        );
+
+        if ($bucket->tokens >= $tokens) {
+            $bucket = new TokenBucket(
+                $bucket->capacity,
+                $bucket->tokens - $tokens,
+                $bucket->lastRefill
+            );
+
+            $this->storage->saveTokenBucket($key, $bucket);
+
+            return RateLimitResult::allowed($capacity, $bucket->tokens);
+        }
+
+        $this->storage->saveTokenBucket($key, $bucket);
+
+        $retryAfter = intval(($tokens - $bucket->tokens) / $refillRate);
+        return RateLimitResult::exceeded($capacity, $bucket->tokens, $retryAfter);
+    }
+
+    public function reset(string $key): void
+    {
+        $this->storage->clear($key);
+    }
+
+    public function getUsage(string $key, int $window): int
+    {
+        $now = $this->timeProvider->getCurrentTime();
+        $windowStart = $now - $window;
+
+        return count($this->storage->getRequestsInWindow($key, $windowStart, $now));
+    }
+}
diff --git a/src/Framework/RateLimit/Storage/CacheStorage.php b/src/Framework/RateLimit/Storage/CacheStorage.php
new file mode 100644
index 00000000..8ed46ca5
--- /dev/null
+++ b/src/Framework/RateLimit/Storage/CacheStorage.php
@@ -0,0 +1,68 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\RateLimit\Storage;
+
+use App\Framework\Cache\Cache;
+use App\Framework\RateLimit\TokenBucket;
+
+final readonly class CacheStorage implements StorageInterface
+{
+    public function __construct(
+        private Cache $cache
+    ) {}
+
+    public function getRequestsInWindow(string $key, int $windowStart, int $windowEnd): array
+    {
+        $requests = $this->cache->get("rate_limit:$key:requests") ?? [];
+
+        // Alte Requests entfernen
+        $requests = array_filter($requests, fn($timestamp) => $timestamp >= $windowStart);
+
+        // Cache aktualisieren
+        $this->cache->set("rate_limit:$key:requests", $requests, 3600);
+
+        return $requests;
+    }
+
+    public function addRequest(string $key, int $timestamp, int $ttl): void
+    {
+        $requests = $this->cache->get("rate_limit:$key:requests") ?? [];
+        $requests[] = $timestamp;
+
+        $this->cache->set("rate_limit:$key:requests", $requests, $ttl);
+    }
+
+    public function getTokenBucket(string $key): ?TokenBucket
+    {
+        $data = $this->cache->get("rate_limit:$key:bucket");
+
+        if ($data === null) {
+            return null;
+        }
+
+        return new TokenBucket(
+            capacity: $data['capacity'],
+            tokens: $data['tokens'],
+            lastRefill: $data['last_refill']
+        );
+    }
+
+    public function saveTokenBucket(string $key, TokenBucket $bucket): void
+    {
+        $data = [
+            'capacity' => $bucket->capacity,
+            'tokens' => $bucket->tokens,
+            'last_refill' => $bucket->lastRefill
+        ];
+
+        $this->cache->set("rate_limit:$key:bucket", $data, 3600);
+    }
+
+    public function clear(string $key): void
+    {
+        $this->cache->forget("rate_limit:$key:requests");
+        $this->cache->forget("rate_limit:$key:bucket");
+    }
+}
diff --git a/src/Framework/RateLimit/Storage/StorageInterface.php b/src/Framework/RateLimit/Storage/StorageInterface.php
new file mode 100644
index 00000000..6d0607fc
--- /dev/null
+++ b/src/Framework/RateLimit/Storage/StorageInterface.php
@@ -0,0 +1,16 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\RateLimit\Storage;
+
+use App\Framework\RateLimit\TokenBucket;
+
+interface StorageInterface
+{
+    public function getRequestsInWindow(string $key, int $windowStart, int $windowEnd): array;
+    public function addRequest(string $key, int $timestamp, int $ttl): void;
+    public function getTokenBucket(string $key): ?TokenBucket;
+    public function saveTokenBucket(string $key, TokenBucket $bucket): void;
+    public function clear(string $key): void;
+}
diff --git a/src/Framework/RateLimit/TimeProvider/SystemTimeProvider.php b/src/Framework/RateLimit/TimeProvider/SystemTimeProvider.php
new file mode 100644
index 00000000..1aebd563
--- /dev/null
+++ b/src/Framework/RateLimit/TimeProvider/SystemTimeProvider.php
@@ -0,0 +1,13 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\RateLimit\TimeProvider;
+
+final readonly class SystemTimeProvider implements TimeProviderInterface
+{
+    public function getCurrentTime(): int
+    {
+        return time();
+    }
+}
diff --git a/src/Framework/RateLimit/TimeProvider/TimeProviderInterface.php b/src/Framework/RateLimit/TimeProvider/TimeProviderInterface.php
new file mode 100644
index 00000000..2823f9d4
--- /dev/null
+++ b/src/Framework/RateLimit/TimeProvider/TimeProviderInterface.php
@@ -0,0 +1,10 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\RateLimit\TimeProvider;
+
+interface TimeProviderInterface
+{
+    public function getCurrentTime(): int;
+}
diff --git a/src/Framework/RateLimit/TokenBucket.php b/src/Framework/RateLimit/TokenBucket.php
new file mode 100644
index 00000000..d43978d9
--- /dev/null
+++ b/src/Framework/RateLimit/TokenBucket.php
@@ -0,0 +1,43 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\RateLimit;
+
+final readonly class TokenBucket
+{
+    public function __construct(
+        public int $capacity,
+        public int $tokens,
+        public int $lastRefill
+    ) {}
+
+    public function canConsume(int $tokens): bool
+    {
+        return $this->tokens >= $tokens;
+    }
+
+    public function consume(int $tokens): self
+    {
+        if (!$this->canConsume($tokens)) {
+            throw new \InvalidArgumentException('Not enough tokens available');
+        }
+
+        return new self(
+            $this->capacity,
+            $this->tokens - $tokens,
+            $this->lastRefill
+        );
+    }
+
+    public function refill(int $tokens, int $timestamp): self
+    {
+        $newTokens = min($this->capacity, $this->tokens + $tokens);
+
+        return new self(
+            $this->capacity,
+            $newTokens,
+            $timestamp
+        );
+    }
+}
diff --git a/src/Framework/Reflection/CachedReflectionProvider.php b/src/Framework/Reflection/CachedReflectionProvider.php
new file mode 100644
index 00000000..fbefb91c
--- /dev/null
+++ b/src/Framework/Reflection/CachedReflectionProvider.php
@@ -0,0 +1,174 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Reflection;
+
+use ReflectionClass;
+use ReflectionMethod;
+use ReflectionParameter;
+use ReflectionProperty;
+use ReflectionException;
+
+final class CachedReflectionProvider implements ReflectionProvider
+{
+    private array $classCache = [];
+    private array $methodCache = [];
+    private array $parameterCache = [];
+    private array $propertyCache = [];
+    private array $attributeCache = [];
+    private array $parameterInfoCache = [];
+    private array $instantiableCache = [];
+    private array $interfaceCache = [];
+    private array $wrappedClassCache = [];
+    private array $wrappedMethodCache = [];
+
+    public function getWrappedClass(string $className): WrappedReflectionClass
+    {
+        return $this->wrappedClassCache[$className] ??= new WrappedReflectionClass(
+            $this->getClass($className)
+        );
+    }
+
+    public function getWrappedMethod(string $className, string $methodName): WrappedReflectionMethod
+    {
+        $key = "{$className}::{$methodName}";
+        return $this->wrappedMethodCache[$key] ??= new WrappedReflectionMethod(
+            $this->getMethod($className, $methodName)
+        );
+    }
+
+    public function getClass(string $className): ReflectionClass
+    {
+        return $this->classCache[$className] ??= new ReflectionClass($className);
+    }
+
+    public function getMethod(string $className, string $methodName): ReflectionMethod
+    {
+        $key = "{$className}::{$methodName}";
+        return $this->methodCache[$key] ??= $this->getClass($className)->getMethod($methodName);
+    }
+
+    public function getMethodParameters(string $className, string $methodName): array
+    {
+        $key = "{$className}::{$methodName}::params";
+        return $this->parameterCache[$key] ??= $this->getMethod($className, $methodName)->getParameters();
+    }
+
+    public function getProperties(string $className): array
+    {
+        $key = "{$className}::properties";
+        return $this->propertyCache[$key] ??= $this->getClass($className)->getProperties();
+    }
+
+    public function getAttributes(string $className, ?string $attributeClass = null): array
+    {
+        $key = "{$className}::attributes::" . ($attributeClass ?? 'all');
+
+        return $this->attributeCache[$key] ??= $attributeClass
+            ? $this->getClass($className)->getAttributes($attributeClass)
+            : $this->getClass($className)->getAttributes();
+    }
+
+    public function getMethodAttributes(string $className, string $methodName, ?string $attributeClass = null): array
+    {
+        $key = "{$className}::{$methodName}::attributes::" . ($attributeClass ?? 'all');
+
+        return $this->attributeCache[$key] ??= $attributeClass
+            ? $this->getMethod($className, $methodName)->getAttributes($attributeClass)
+            : $this->getMethod($className, $methodName)->getAttributes();
+    }
+
+    public function hasAttribute(string $className, string $attributeClass): bool
+    {
+        return !empty($this->getAttributes($className, $attributeClass));
+    }
+
+    public function getParameterInfo(string $className, string $methodName): array
+    {
+        $key = "{$className}::{$methodName}::paramInfo";
+
+        return $this->parameterInfoCache[$key] ??= $this->buildParameterInfo($className, $methodName);
+    }
+
+    public function isInstantiable(string $className): bool
+    {
+        return $this->instantiableCache[$className] ??= $this->getClass($className)->isInstantiable();
+    }
+
+    public function implementsInterface(string $className, string $interfaceName): bool
+    {
+        $key = "{$className}::implements::{$interfaceName}";
+
+        return $this->interfaceCache[$key] ??= $this->getClass($className)->implementsInterface($interfaceName);
+    }
+
+    private function buildParameterInfo(string $className, string $methodName): array
+    {
+        $parameters = $this->getMethodParameters($className, $methodName);
+        $paramInfo = [];
+
+        foreach ($parameters as $param) {
+            $type = $param->getType();
+            $paramInfo[] = [
+                'name' => $param->getName(),
+                'type' => $type ? $type->getName() : null,
+                'isBuiltin' => $type ? $type->isBuiltin() : true,
+                'allowsNull' => $param->allowsNull(),
+                'isOptional' => $param->isOptional(),
+                'hasDefaultValue' => $param->isDefaultValueAvailable(),
+                'default' => $param->isDefaultValueAvailable() ? $param->getDefaultValue() : null,
+                'position' => $param->getPosition(),
+            ];
+        }
+
+        return $paramInfo;
+    }
+
+    public function forget(string $className): void
+    {
+        unset($this->classCache[$className]);
+        unset($this->instantiableCache[$className]);
+        unset($this->wrappedClassCache[$className]);
+
+        // Alle zugehörigen Caches leeren
+        $this->clearRelatedCaches($className);
+    }
+
+    public function flush(): void
+    {
+        $this->classCache = [];
+        $this->methodCache = [];
+        $this->parameterCache = [];
+        $this->propertyCache = [];
+        $this->attributeCache = [];
+        $this->parameterInfoCache = [];
+        $this->instantiableCache = [];
+        $this->interfaceCache = [];
+        $this->wrappedClassCache = [];
+        $this->wrappedMethodCache = [];
+    }
+
+    private function clearRelatedCaches(string $className): void
+    {
+        $prefix = $className . '::';
+
+        $caches = [
+            &$this->methodCache,
+            &$this->parameterCache,
+            &$this->propertyCache,
+            &$this->attributeCache,
+            &$this->parameterInfoCache,
+            &$this->interfaceCache,
+            &$this->wrappedMethodCache
+        ];
+
+        foreach ($caches as &$cache) {
+            $cache = array_filter(
+                $cache,
+                fn($key) => !str_starts_with($key, $prefix),
+                ARRAY_FILTER_USE_KEY
+            );
+        }
+    }
+}
diff --git a/src/Framework/Reflection/ReflectionProvider.php b/src/Framework/Reflection/ReflectionProvider.php
new file mode 100644
index 00000000..c28a9773
--- /dev/null
+++ b/src/Framework/Reflection/ReflectionProvider.php
@@ -0,0 +1,43 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Reflection;
+
+use ReflectionClass;
+use ReflectionMethod;
+use ReflectionParameter;
+use ReflectionProperty;
+
+interface ReflectionProvider
+{
+    // Wrapped Objekte für erweiterte API
+    public function getWrappedClass(string $className): WrappedReflectionClass;
+
+    public function getWrappedMethod(string $className, string $methodName): WrappedReflectionMethod;
+
+    // Original Reflection Objekte
+    public function getClass(string $className): ReflectionClass;
+
+    public function getMethod(string $className, string $methodName): ReflectionMethod;
+
+    public function getMethodParameters(string $className, string $methodName): array;
+
+    public function getProperties(string $className): array;
+
+    public function getAttributes(string $className, ?string $attributeClass = null): array;
+
+    public function getMethodAttributes(string $className, string $methodName, ?string $attributeClass = null): array;
+
+    public function hasAttribute(string $className, string $attributeClass): bool;
+
+    public function getParameterInfo(string $className, string $methodName): array;
+
+    public function isInstantiable(string $className): bool;
+
+    public function implementsInterface(string $className, string $interfaceName): bool;
+
+    public function forget(string $className): void;
+
+    public function flush(): void;
+}
diff --git a/src/Framework/Reflection/WrappedReflectionClass.php b/src/Framework/Reflection/WrappedReflectionClass.php
new file mode 100644
index 00000000..0fbf0a24
--- /dev/null
+++ b/src/Framework/Reflection/WrappedReflectionClass.php
@@ -0,0 +1,77 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Reflection;
+
+use ReflectionClass;
+use ReflectionAttribute;
+
+final readonly class WrappedReflectionClass
+{
+    public function __construct(
+        public ReflectionClass $reflection
+    ) {}
+
+    public function getName(): string
+    {
+        return $this->reflection->getName();
+    }
+
+    public function getShortName(): string
+    {
+        return $this->reflection->getShortName();
+    }
+
+    public function isInstantiable(): bool
+    {
+        return $this->reflection->isInstantiable();
+    }
+
+    public function implementsInterface(string $interface): bool
+    {
+        return $this->reflection->implementsInterface($interface);
+    }
+
+    // Erweiterte Convenience-Methoden
+    public function getAttributeInstances(?string $attributeClass = null): array
+    {
+        $attributes = $this->reflection->getAttributes($attributeClass);
+        return array_map(fn(ReflectionAttribute $attr) => $attr->newInstance(), $attributes);
+    }
+
+    public function hasAttribute(string $attributeClass): bool
+    {
+        return !empty($this->reflection->getAttributes($attributeClass));
+    }
+
+    public function getFirstAttribute(string $attributeClass): ?object
+    {
+        $instances = $this->getAttributeInstances($attributeClass);
+        return $instances[0] ?? null;
+    }
+
+    public function getMethodsWithAttribute(string $attributeClass): array
+    {
+        $methods = [];
+        foreach ($this->reflection->getMethods() as $method) {
+            if (!empty($method->getAttributes($attributeClass))) {
+                $methods[] = new WrappedReflectionMethod($method);
+            }
+        }
+        return $methods;
+    }
+
+    public function getWrappedMethod(string $name): WrappedReflectionMethod
+    {
+        return new WrappedReflectionMethod($this->reflection->getMethod($name));
+    }
+
+    public function getWrappedMethods(?int $filter = null): array
+    {
+        return array_map(
+            fn($method) => new WrappedReflectionMethod($method),
+            $this->reflection->getMethods($filter)
+        );
+    }
+}
diff --git a/src/Framework/Reflection/WrappedReflectionMethod.php b/src/Framework/Reflection/WrappedReflectionMethod.php
new file mode 100644
index 00000000..1ef6ab3d
--- /dev/null
+++ b/src/Framework/Reflection/WrappedReflectionMethod.php
@@ -0,0 +1,65 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Reflection;
+
+use ReflectionMethod;
+use ReflectionAttribute;
+
+final readonly class WrappedReflectionMethod
+{
+    public function __construct(
+        public ReflectionMethod $reflection
+    ) {}
+
+    public function getName(): string
+    {
+        return $this->reflection->getName();
+    }
+
+    public function getWrappedParameters(): array
+    {
+        return array_map(
+            fn($param) => new WrappedReflectionParameter($param),
+            $this->reflection->getParameters()
+        );
+    }
+
+    // Erweiterte Parameter-Info als Array (für DI)
+    public function getParameterInfo(): array
+    {
+        $params = [];
+        foreach ($this->reflection->getParameters() as $param) {
+            $type = $param->getType();
+            $params[] = [
+                'name' => $param->getName(),
+                'type' => $type ? $type->getName() : null,
+                'isBuiltin' => $type ? $type->isBuiltin() : true,
+                'allowsNull' => $param->allowsNull(),
+                'isOptional' => $param->isOptional(),
+                'hasDefaultValue' => $param->isDefaultValueAvailable(),
+                'default' => $param->isDefaultValueAvailable() ? $param->getDefaultValue() : null,
+                'position' => $param->getPosition(),
+            ];
+        }
+        return $params;
+    }
+
+    public function getAttributeInstances(?string $attributeClass = null): array
+    {
+        $attributes = $this->reflection->getAttributes($attributeClass);
+        return array_map(fn(ReflectionAttribute $attr) => $attr->newInstance(), $attributes);
+    }
+
+    public function hasAttribute(string $attributeClass): bool
+    {
+        return !empty($this->reflection->getAttributes($attributeClass));
+    }
+
+    public function getFirstAttribute(string $attributeClass): ?object
+    {
+        $instances = $this->getAttributeInstances($attributeClass);
+        return $instances[0] ?? null;
+    }
+}
diff --git a/src/Framework/Reflection/WrappedReflectionParameter.php b/src/Framework/Reflection/WrappedReflectionParameter.php
new file mode 100644
index 00000000..d6b911bf
--- /dev/null
+++ b/src/Framework/Reflection/WrappedReflectionParameter.php
@@ -0,0 +1,73 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Reflection;
+
+use ReflectionParameter;
+
+final readonly class WrappedReflectionParameter
+{
+    public function __construct(
+        public ReflectionParameter $reflection
+    ) {}
+
+    public function getName(): string
+    {
+        return $this->reflection->getName();
+    }
+
+    public function getTypeName(): ?string
+    {
+        $type = $this->reflection->getType();
+        return $type ? $type->getName() : null;
+    }
+
+    public function isBuiltin(): bool
+    {
+        $type = $this->reflection->getType();
+        return $type ? $type->isBuiltin() : true;
+    }
+
+    public function isOptional(): bool
+    {
+        return $this->reflection->isOptional();
+    }
+
+    public function hasDefaultValue(): bool
+    {
+        return $this->reflection->isDefaultValueAvailable();
+    }
+
+    public function getDefaultValue(): mixed
+    {
+        return $this->reflection->isDefaultValueAvailable()
+            ? $this->reflection->getDefaultValue()
+            : null;
+    }
+
+    public function allowsNull(): bool
+    {
+        return $this->reflection->allowsNull();
+    }
+
+    public function getPosition(): int
+    {
+        return $this->reflection->getPosition();
+    }
+
+    // Convenience-Methode für DI
+    public function toArray(): array
+    {
+        return [
+            'name' => $this->getName(),
+            'type' => $this->getTypeName(),
+            'isBuiltin' => $this->isBuiltin(),
+            'allowsNull' => $this->allowsNull(),
+            'isOptional' => $this->isOptional(),
+            'hasDefaultValue' => $this->hasDefaultValue(),
+            'default' => $this->getDefaultValue(),
+            'position' => $this->getPosition(),
+        ];
+    }
+}
diff --git a/src/Framework/Router/ActionResult.php b/src/Framework/Router/ActionResult.php
index b519a74e..7c82f14d 100644
--- a/src/Framework/Router/ActionResult.php
+++ b/src/Framework/Router/ActionResult.php
@@ -1,20 +1,8 @@
 <?php
 
-declare(strict_types=1);
-
 namespace App\Framework\Router;
 
-use App\Framework\Http\Status;
-
-final readonly class ActionResult
+interface ActionResult
 {
-    public function __construct(
-        public ResultType $resultType,
-        public string $template,
-        public array $data = [],
-        public Status $status = Status::OK,
-        public string $layout = '',
-        public array $slots = [],
-        public ?string $controllerClass = null
-    ) {}
+
 }
diff --git a/src/Framework/Router/CompiledPattern.php b/src/Framework/Router/CompiledPattern.php
new file mode 100644
index 00000000..a5a3c892
--- /dev/null
+++ b/src/Framework/Router/CompiledPattern.php
@@ -0,0 +1,15 @@
+<?php
+
+namespace App\Framework\Router;
+
+final readonly class CompiledPattern
+{
+    /**
+     * @param string $regex Kombinierter Regex
+     * @param array<int, array{route: object, paramMap: array<string, int>}> $routes
+     */
+    public function __construct(
+        public string $regex,
+        public array $routes
+    ) {}
+}
diff --git a/src/Framework/Router/CompiledRoutes.php b/src/Framework/Router/CompiledRoutes.php
new file mode 100644
index 00000000..1098bada
--- /dev/null
+++ b/src/Framework/Router/CompiledRoutes.php
@@ -0,0 +1,77 @@
+<?php
+
+namespace App\Framework\Router;
+
+use App\Framework\Core\Route;
+
+final readonly class CompiledRoutes
+{
+    /**
+     * @param array<string, array<string, Route>> $staticRoutes
+     * @param array<string, CompiledPattern|null> $dynamicPatterns
+     */
+    public function __construct(
+        private array $staticRoutes,
+        private array $dynamicPatterns,
+        private array $namedRoutes,
+    ) {}
+
+    public function getStaticRoute(string $method, string $path): ?Route
+    {
+        return $this->staticRoutes[$method][$path] ?? null;
+    }
+
+    public function getCompiledPattern(string $method): ?CompiledPattern
+    {
+        return $this->dynamicPatterns[$method] ?? null;
+    }
+
+    public function getNamedRoute(string $name): ?Route
+    {
+        return $this->namedRoutes[$name] ?? null;
+    }
+
+    public function hasNamedRoute(string $name): bool
+    {
+        return isset($this->namedRoutes[$name]);
+    }
+
+    public function getAllNamedRoutes(): array
+    {
+        return $this->namedRoutes;
+    }
+
+    public function generateUrl(string $name, array $params = []): ?string
+    {
+        $route = $this->getNamedRoute($name);
+        if(!$route) {
+            return null;
+        }
+        return $this->buildUrlFromRoute($route, $params);
+    }
+
+
+    public function getStats(): array
+    {
+        $staticCount = array_sum(array_map('count', $this->staticRoutes));
+        $dynamicCount = count(array_filter($this->dynamicPatterns));
+        $namedCount = count($this->namedRoutes);
+
+        return [
+            'static_routes' => $staticCount,
+            'dynamic_patterns' => $dynamicCount,
+            'named_routes' => $namedCount,
+            'total_methods' => count($this->staticRoutes)
+        ];
+    }
+
+    private function buildUrlFromRoute(Route $route, array $params): string
+    {
+        $path = $route->path;
+
+        foreach ($params as $key => $value) {
+            $path = str_replace("{{$key}}", (string)$value, $path);
+        }
+        return $path;
+    }
+}
diff --git a/src/Framework/Router/ControllerRequestFactory.php b/src/Framework/Router/ControllerRequestFactory.php
new file mode 100644
index 00000000..f8565ee0
--- /dev/null
+++ b/src/Framework/Router/ControllerRequestFactory.php
@@ -0,0 +1,61 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Router;
+
+use App\Framework\DI\DefaultContainer;
+use App\Framework\Http\Request;
+use App\Framework\Http\RequestBody;
+use App\Framework\Http\Session\Session;
+use App\Framework\Validation\Exceptions\ValidationException;
+use App\Framework\Validation\Validator;
+use Exception;
+use ReflectionClass;
+use ReflectionNamedType;
+use ReflectionProperty;
+
+final readonly class ControllerRequestFactory
+{
+    public function __construct(
+        private DefaultContainer       $container,
+        private PropertyValueConverter $propertyValueConverter
+    ) {}
+
+    /**
+     * Erstellt und validiert eine ControllerRequest-Instanz
+     */
+    public function createAndValidate(ReflectionClass $requestClass, RequestBody $data): object
+    {
+        // Instanz erstellen
+        $instance = $requestClass->newInstance();
+
+        // Eigenschaften befüllen und validieren
+        foreach ($requestClass->getProperties() as $property) {
+            $propertyName = $property->getName();
+
+            // Wert aus den Daten abrufen
+            $value = $data->get($propertyName, null);
+
+            try {
+                $this->propertyValueConverter->setPropertyValue($property, $instance, $value);
+            } catch (\Throwable $e) {
+                #throw new ValidationException(
+                #    ['Ungültiger Wert für den Typ: ' . $e->getMessage()],
+                #    $propertyName
+                #);
+            }
+        }
+
+        $validator = $this->container->get(Validator::class);
+
+        $validationResult = $validator->validate($instance);
+
+        if ($validationResult->hasErrors()) {
+
+            throw new ValidationException($validationResult, 'test');
+        }
+
+        return $instance;
+    }
+}
diff --git a/src/Framework/Router/Exception/RouteNotFound.php b/src/Framework/Router/Exception/RouteNotFound.php
new file mode 100644
index 00000000..a8aaaedf
--- /dev/null
+++ b/src/Framework/Router/Exception/RouteNotFound.php
@@ -0,0 +1,27 @@
+<?php
+
+namespace App\Framework\Router\Exception;
+
+use App\Framework\Exception\FrameworkException;
+use App\Framework\Http\Exception\HttpException;
+use App\Framework\Http\Status;
+
+class RouteNotFound extends FrameworkException implements HttpException
+{
+    public Status $status {
+        get {
+            return Status::NOT_FOUND;
+        }
+    }
+
+    protected string $route;
+
+    public function __construct(string $route, ?\Throwable $previous = null, int $code = 0, array $context = [])
+    {
+        $this->route = $route;
+        $message = "Route not found: {$route}";
+
+        #$context
+        parent::__construct($message, $code, $previous);
+    }
+}
diff --git a/src/Framework/Router/Exceptions/ParameterResolutionException.php b/src/Framework/Router/Exceptions/ParameterResolutionException.php
new file mode 100644
index 00000000..f9d73151
--- /dev/null
+++ b/src/Framework/Router/Exceptions/ParameterResolutionException.php
@@ -0,0 +1,19 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Router\Exceptions;
+
+use App\Framework\Exception\FrameworkException;
+
+final class ParameterResolutionException extends FrameworkException
+{
+
+    /**
+     * @param string $string
+     * @param int $int
+     * @param \Exception|ReflectionException $e
+     */
+    public function __construct(string $string, int $int, \Throwable $e) {
+        parent::__construct($string, $int, $e);
+    }
+}
diff --git a/src/Framework/Router/Exceptions/UnknownResultException.php b/src/Framework/Router/Exceptions/UnknownResultException.php
new file mode 100644
index 00000000..8071287d
--- /dev/null
+++ b/src/Framework/Router/Exceptions/UnknownResultException.php
@@ -0,0 +1,23 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Router\Exceptions;
+
+use App\Framework\Exception\FrameworkException;
+
+final class UnknownResultException extends FrameworkException
+{
+    public function __construct(
+        string $resultClass,
+        int $code = 0,
+        ?\Throwable $previous = null
+    ) {
+        parent::__construct(
+            message: 'Unbekanntes Ergebnisobjekt: ' . $resultClass,
+            code: $code,
+            previous: $previous,
+            context: ['resultClass' => $resultClass]
+        );
+    }
+}
diff --git a/src/Framework/Router/GenericActionResult.php b/src/Framework/Router/GenericActionResult.php
new file mode 100644
index 00000000..c7ad8478
--- /dev/null
+++ b/src/Framework/Router/GenericActionResult.php
@@ -0,0 +1,20 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Router;
+
+use App\Framework\Http\Status;
+
+final readonly class GenericActionResult implements ActionResult
+{
+    private function __construct(
+        public ResultType $resultType,
+        public string $template,
+        public array $data = [],
+        public Status $status = Status::OK,
+        #public string $layout = '',
+        public array $slots = [],
+        public ?string $controllerClass = null
+    ) {}
+}
diff --git a/src/Framework/Router/HttpRouter.php b/src/Framework/Router/HttpRouter.php
index 382bb29c..51d6d8e2 100644
--- a/src/Framework/Router/HttpRouter.php
+++ b/src/Framework/Router/HttpRouter.php
@@ -4,13 +4,17 @@ declare(strict_types=1);
 
 namespace App\Framework\Router;
 
+use App\Framework\Attributes\Singleton;
 use App\Framework\Core\DynamicRoute;
-use App\Framework\Http\HttpMethod;
+use App\Framework\Http\Method;
+use App\Framework\Http\Request;
 
+#[Singleton]
 final readonly class HttpRouter
 {
     public function __construct(
-        private RouteCollection $routes
+        #public RouteCollection $routes,
+        public CompiledRoutes $optimizedRoutes,
     ) {}
 
     /**
@@ -19,30 +23,58 @@ final readonly class HttpRouter
      * @param string $method HTTP-Methode, zB. GET, POST
      * @param string $path URI-Pfad, zB. /user/123
      */
-    public function match(string $method, string $path): RouteContext
+    public function match(Request $request): RouteContext
     {
-        $method = HttpMethod::tryFrom(strtoupper($method));
+        $method = $request->method;
+        $path = $request->path;
 
-        if ($method === null || !$this->routes->has($method->value)) {
+        if($staticRoute = $this->optimizedRoutes->getStaticRoute($method->value, $path)) {
             return new RouteContext(
-                match: new NoRouteMatch(),
-                method: $method->value,
+                match: new RouteMatchSuccess($staticRoute),
+                method: $method,
                 path: $path
             );
         }
 
-        $match =  $this->matchStatic($method->value, $path)
-            ?? $this->matchDynamic($method->value, $path)
+        if($dynamicMatch = $this->matchDynamicOptimized($method, $path)) {
+            return new RouteContext(
+                match: new RouteMatchSuccess($dynamicMatch),
+                method: $method,
+                path: $path
+            );
+        }
+
+        return new RouteContext(
+            match: new NoRouteMatch(),
+            method: $method,
+            path: $path
+        );
+
+        /*
+        $method = $request->method;
+        $path = $request->path;
+
+        if (!$this->routes->has($method)) {
+            return new RouteContext(
+                match: new NoRouteMatch(),
+                method: $method,
+                path: $path
+            );
+        }
+
+        $match =  $this->matchStatic($method, $path)
+            ?? $this->matchDynamic($method, $path)
             ?? new NoRouteMatch();
 
         return new RouteContext(
             match: $match,
-            method: $method->value,
+            method: $method,
             path: $path
-        );
+        );*/
     }
 
-    private function matchStatic(string $method, string $path): ?RouteMatch
+
+    private function matchStatic(Method $method, string $path): ?RouteMatch
     {
         if (isset($this->routes->getStatic($method)[$path])) {
             $handler = $this->routes->getStatic($method)[$path];
@@ -51,25 +83,100 @@ final readonly class HttpRouter
         return null;
     }
 
-    private function matchDynamic(string $method, string $path): ?RouteMatch
+    private function matchDynamic(Method $method, string $path): ?RouteMatch
     {
+        /* @var $route DynamicRoute */
         foreach ($this->routes->getDynamic($method) as $route) {
-            if (preg_match($route['regex'], $path, $matches)) {
+
+            if (preg_match($route->regex, $path, $matches)) {
+
                 array_shift($matches); // remove full match
-                $params = array_combine($route['params'], $matches);
+
+                // Überprüfe ob die Anzahl der URL-Parameter stimmt
+                if (count($route->paramNames) !== count($matches)) {
+                    continue;
+                }
+
+                $paramValues = array_combine($route->paramNames, $matches);
+
+                if (!$paramValues) {
+                    continue;
+                }
 
                 $dynamicRoute = new DynamicRoute(
-                    $route["regex"],
-                    $route["params"],
-                    $route['method']['class'],
-                    $route['method']['method'],
-                    $params
+                    $route->regex,
+                    $route->paramNames,
+                    $route->controller,
+                    $route->action,
+                    $route->parameters,
+                    $paramValues,
+                    $route->name,
+                    $route->path,
                 );
-
-                return new RouteMatchSuccess($route);
+                return new RouteMatchSuccess($dynamicRoute);
             }
         }
 
         return null;
     }
+
+    private function matchDynamicOptimized(Method $method, string $path): ?DynamicRoute
+    {
+        $pattern = $this->optimizedRoutes->getCompiledPattern($method->value);
+
+        if(!$pattern || !preg_match($pattern->regex, $path, $matches)) {
+            return null;
+        }
+
+        $routeIndex = $this->findMatchingRouteIndex($matches, $method);
+        $routeData = $pattern->routes[$routeIndex];
+        $paramValues = $this->extractParameters($matches, $routeData['paramMap']);
+
+        $originalRoute = $routeData['route'];
+        return new DynamicRoute(
+            regex: $originalRoute->regex,
+            paramNames: $originalRoute->paramNames,
+            controller: $originalRoute->controller,
+            action: $originalRoute->action,
+            parameters: $originalRoute->parameters,
+            paramValues: $paramValues,
+            name: $originalRoute->name,
+            path: $originalRoute->path,
+            attributes: $originalRoute->attributes ?? [],
+        );
+    }
+
+    private function findMatchingRouteIndex(array $matches, $method): int
+    {
+        $pattern = $this->optimizedRoutes->getCompiledPattern($method->value);
+
+        foreach($pattern->routes as $index => $routeData) {
+            $routeGroupIndex = $routeData['routeGroupIndex'];
+
+            if (isset($matches[$routeGroupIndex]) && $matches[$routeGroupIndex] !== '') {
+                return $index;
+            }
+        }
+
+        return 0;
+
+
+        for($i = 1; $i < count($matches); $i++) {
+            if($matches[$i] !== '') {
+                return $i - 1;
+            }
+        }
+        return 0;
+    }
+
+    private function extractParameters(array $matches, array $paramMap): array
+    {
+        $params = [];
+        foreach($paramMap as $paramName => $matchIndex) {
+            if (isset($matches[$matchIndex]) && $matches[$matchIndex] !== '') {
+                $params[$paramName] = $matches[$matchIndex];
+            }
+        }
+        return $params;
+    }
 }
diff --git a/src/Framework/Router/ParameterProcessor.php b/src/Framework/Router/ParameterProcessor.php
new file mode 100644
index 00000000..2f06a2fa
--- /dev/null
+++ b/src/Framework/Router/ParameterProcessor.php
@@ -0,0 +1,76 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Router;
+
+use App\Framework\DI\DefaultContainer;
+use App\Framework\Http\ControllerRequest;
+use App\Framework\Http\Request;
+use App\Framework\Logging\DefaultLogger;
+use App\Framework\Router\Exceptions\ParameterResolutionException;
+use ReflectionClass;
+use ReflectionException;
+
+final readonly class ParameterProcessor
+{
+    public function __construct(
+        private DefaultContainer         $container,
+        private ControllerRequestFactory $controllerRequestFactory,
+        private DefaultLogger            $logger
+    ) {}
+
+    public function prepareParameters(array $params, array $queryParams): array
+    {
+        $parameters = [];
+
+        foreach ($params as $param) {
+            try {
+                if(in_array($param['name'], array_keys($queryParams))) {
+                    $parameters[] = $queryParams[$param['name']];
+                    continue;
+                }
+
+                if ($param['isBuiltin'] === true) {
+                    $parameters[] = $param['default'] ?? null;
+                    continue;
+                }
+
+                $reflectionClass = new ReflectionClass($param['type']);
+
+                if ($reflectionClass->implementsInterface(ControllerRequest::class)) {
+                    $request = $this->container->get(Request::class);
+                    $parsedBody = $request->parsedBody;
+
+                    $controllerRequest = $this->controllerRequestFactory
+                        ->createAndValidate($reflectionClass, $parsedBody);
+
+                    $this->container->bind($param['type'], $controllerRequest);
+                    $parameters[] = $controllerRequest;
+                    continue;
+                }
+
+                $parameters[] = $this->container->get($param['type']);
+
+            } catch (ReflectionException $e) {
+                $this->logger?->error("Parameter reflection failed", [
+                    'type' => $param['type'],
+                    'error' => $e->getMessage()
+                ]);
+                throw new ParameterResolutionException(
+                    "Cannot resolve parameter of type '{$param['type']}'",
+                    0,
+                    $e
+                );
+            } catch (\Throwable $e) {
+                $this->logger?->error("Parameter preparation failed", [
+                    'param' => $param,
+                    'error' => $e->getMessage()
+                ]);
+                throw $e;
+            }
+        }
+
+        return $parameters;
+    }
+}
diff --git a/src/Framework/Router/PropertyValueConverter.php b/src/Framework/Router/PropertyValueConverter.php
new file mode 100644
index 00000000..1decad4b
--- /dev/null
+++ b/src/Framework/Router/PropertyValueConverter.php
@@ -0,0 +1,51 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Router;
+
+use ReflectionNamedType;
+use ReflectionProperty;
+
+final readonly class PropertyValueConverter
+{
+    /**
+     * Setzt einen Wert für eine Property mit entsprechender Typenkonvertierung
+     */
+    public function setPropertyValue(ReflectionProperty $property, object $instance, mixed $value): void
+    {
+        if ($property->hasDefaultValue()) {
+            $property->setValue($instance, $property->getDefaultValue());
+            return;
+        }
+
+        if ($value === null) {
+            $property->setValue($instance, null);
+            return;
+        }
+
+        $type = $property->getType();
+
+        if ($type instanceof ReflectionNamedType) {
+            $typeName = $type->getName();
+            $value = $this->convertValueToType($value, $typeName);
+        }
+
+        $property->setValue($instance, $value);
+    }
+
+    /**
+     * Konvertiert einen Wert in den angegebenen Typ
+     */
+    private function convertValueToType(mixed $value, string $typeName): mixed
+    {
+        return match ($typeName) {
+            'int' => (int) $value,
+            'float' => (float) $value,
+            'bool' => filter_var($value, FILTER_VALIDATE_BOOLEAN),
+            'string' => (string) $value,
+            'array' => is_array($value) ? $value : [$value],
+            default => $value
+        };
+    }
+}
diff --git a/src/Framework/Router/Result/ContentNegotiationResult.php b/src/Framework/Router/Result/ContentNegotiationResult.php
new file mode 100644
index 00000000..37eaacb2
--- /dev/null
+++ b/src/Framework/Router/Result/ContentNegotiationResult.php
@@ -0,0 +1,15 @@
+<?php
+
+namespace App\Framework\Router\Result;
+
+use App\Framework\Router\ActionResult;
+
+final readonly class ContentNegotiationResult implements ActionResult
+{
+    public function __construct(
+        public array $jsonPayload = [],
+        public ?string $redirectTo = null,
+        public ?string $viewTemplate = null,
+        public array $viewData = [],
+    ) {}
+}
diff --git a/src/Framework/Router/Result/FileResult.php b/src/Framework/Router/Result/FileResult.php
new file mode 100644
index 00000000..c1d61c28
--- /dev/null
+++ b/src/Framework/Router/Result/FileResult.php
@@ -0,0 +1,14 @@
+<?php
+
+namespace App\Framework\Router\Result;
+
+use App\Framework\Router\ActionResult;
+
+final readonly class FileResult implements ActionResult
+{
+    public function __construct(
+        public string $filePath,
+        public string $variant = 'original',
+        public string $mimeType = 'application/image',
+    ) {}
+}
diff --git a/src/Framework/Router/Result/JsonResult.php b/src/Framework/Router/Result/JsonResult.php
new file mode 100644
index 00000000..8fbf9631
--- /dev/null
+++ b/src/Framework/Router/Result/JsonResult.php
@@ -0,0 +1,15 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Router\Result;
+
+use App\Framework\Http\Status;
+use App\Framework\Router\ActionResult;
+
+final class JsonResult implements ActionResult
+{
+    public function __construct(
+        public readonly array $data,
+        public Status $status = Status::OK,
+    ) {}
+}
diff --git a/src/Framework/Router/Result/Redirect.php b/src/Framework/Router/Result/Redirect.php
new file mode 100644
index 00000000..ec26d2cd
--- /dev/null
+++ b/src/Framework/Router/Result/Redirect.php
@@ -0,0 +1,15 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Router\Result;
+
+use App\Framework\Http\Status;
+use App\Framework\Router\ActionResult;
+
+final class Redirect implements ActionResult
+{
+    public Status $status = Status::FOUND;
+    public function __construct(
+        public readonly string $target,
+    ) {}
+}
diff --git a/src/Framework/Router/Result/SseEvent.php b/src/Framework/Router/Result/SseEvent.php
new file mode 100644
index 00000000..f1c89b3d
--- /dev/null
+++ b/src/Framework/Router/Result/SseEvent.php
@@ -0,0 +1,52 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Router\Result;
+
+/**
+ * Repräsentiert ein einzelnes Server-Sent Event
+ */
+final readonly class SseEvent
+{
+    /**
+     * @param string $data Der Dateninhalt des Events
+     * @param string|null $event Der Event-Typ (optional)
+     * @param string|null $id Die Event-ID (optional)
+     * @param int|null $retry Retry-Intervall in Millisekunden (optional)
+     */
+    public function __construct(
+        public string $data,
+        public ?string $event = null,
+        public ?string $id = null,
+        public ?int $retry = null
+    ) {}
+
+    /**
+     * Formatiert das Event in das SSE-Protokollformat
+     */
+    public function format(): string
+    {
+        $formatted = [];
+
+        if ($this->id !== null) {
+            $formatted[] = "id: {$this->id}";
+        }
+
+        if ($this->event !== null) {
+            $formatted[] = "event: {$this->event}";
+        }
+
+        if ($this->retry !== null) {
+            $formatted[] = "retry: {$this->retry}";
+        }
+
+        // Mehrzeilige Daten unterstützen
+        foreach (explode("\n", $this->data) as $line) {
+            $formatted[] = "data: {$line}";
+        }
+
+        $formatted[] = ''; // Leere Zeile am Ende
+
+        return implode("\n", $formatted);
+    }
+}
diff --git a/src/Framework/Router/Result/SseResult.php b/src/Framework/Router/Result/SseResult.php
new file mode 100644
index 00000000..ec7c115c
--- /dev/null
+++ b/src/Framework/Router/Result/SseResult.php
@@ -0,0 +1,72 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Router\Result;
+
+use App\Framework\Http\Status;
+use App\Framework\Router\ActionResult;
+use Closure;
+
+final class SseResult implements ActionResult
+{
+    /**
+     * @var array<SseEvent> Enthält die SSE-Events, die beim initialen Verbindungsaufbau gesendet werden
+     */
+    private array $initialEvents = [];
+
+    /**
+     * @param Status $status HTTP-Status-Code der Antwort
+     * @param int|null $retryInterval Zeit in Millisekunden, nach der der Client bei Verbindungsverlust neu verbinden soll
+     * @param array<string, string> $headers Zusätzliche HTTP-Header für die Response
+     */
+    public function __construct(
+        public readonly Status $status = Status::OK,
+        public readonly ?int $retryInterval = 3000,
+        public readonly array $headers = [],
+
+        public readonly ?Closure $callback = null,
+        public readonly int $maxDuration = 0,
+        public readonly int $heartbeatInterval = 30,
+
+    ) {}
+
+    /**
+     * Fügt ein Event hinzu, das beim initialen Verbindungsaufbau gesendet wird
+     */
+    public function addEvent(
+        string $data,
+        ?string $event = null,
+        ?string $id = null,
+        ?int $retry = null
+    ): self {
+        $this->initialEvents[] = new SseEvent($data, $event, $id, $retry);
+        return $this;
+    }
+
+    /**
+     * Fügt ein JSON-formatiertes Event hinzu
+     */
+    public function addJsonEvent(
+        array $data,
+        ?string $event = null,
+        ?string $id = null,
+        ?int $retry = null
+    ): self {
+        return $this->addEvent(json_encode($data), $event, $id, $retry);
+    }
+
+    /**
+     * Gibt alle initialen Events zurück
+     *
+     * @return array<SseEvent>
+     */
+    public function getInitialEvents(): array
+    {
+        return $this->initialEvents;
+    }
+
+    public function hasCallback(): bool
+    {
+        return $this->callback !== null;
+    }
+}
diff --git a/src/Framework/Router/Result/SseResultWithCallback.php b/src/Framework/Router/Result/SseResultWithCallback.php
new file mode 100644
index 00000000..d07ab804
--- /dev/null
+++ b/src/Framework/Router/Result/SseResultWithCallback.php
@@ -0,0 +1,92 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Router\Result;
+
+use App\Framework\Http\SseStream;
+use App\Framework\Http\Status;
+use App\Framework\Router\ActionResult;
+
+/**
+ * Erweiterte SSE-Klasse, die eine Callback-Funktion für Live-Updates unterstützt
+ */
+final class SseResultWithCallback implements ActionResult
+{
+    /**
+     * @var callable|null Callback-Funktion, die während des Streamings ausgeführt wird
+     */
+    private $callback = null;
+
+    /**
+     * @var int Maximale Streaming-Dauer in Sekunden (0 = unbegrenzt)
+     */
+    private int $maxDuration = 0;
+
+    /**
+     * @var int Intervall für Heartbeats in Sekunden
+     */
+    private int $heartbeatInterval = 30;
+
+    public function __construct(
+        public readonly Status $status = Status::OK,
+        public readonly array $headers = []
+    ) {}
+
+    /**
+     * Setzt die Callback-Funktion, die während des Streamings aufgerufen wird
+     * Der Callback erhält den SseStream als Parameter
+     *
+     * @param callable $callback Funktion mit Signatur: function(SseStream $stream): void
+     */
+    public function setCallback(callable $callback): self
+    {
+        $this->callback = $callback;
+        return $this;
+    }
+
+    /**
+     * Setzt die maximale Streaming-Dauer
+     *
+     * @param int $seconds Maximale Dauer in Sekunden (0 = unbegrenzt)
+     */
+    public function setMaxDuration(int $seconds): self
+    {
+        $this->maxDuration = $seconds;
+        return $this;
+    }
+
+    /**
+     * Setzt das Intervall für Heartbeats
+     *
+     * @param int $seconds Intervall in Sekunden
+     */
+    public function setHeartbeatInterval(int $seconds): self
+    {
+        $this->heartbeatInterval = $seconds;
+        return $this;
+    }
+
+    /**
+     * Gibt den Callback zurück
+     */
+    public function getCallback(): ?callable
+    {
+        return $this->callback;
+    }
+
+    /**
+     * Gibt die maximale Streaming-Dauer zurück
+     */
+    public function getMaxDuration(): int
+    {
+        return $this->maxDuration;
+    }
+
+    /**
+     * Gibt das Heartbeat-Intervall zurück
+     */
+    public function getHeartbeatInterval(): int
+    {
+        return $this->heartbeatInterval;
+    }
+}
diff --git a/src/Framework/Router/Result/ViewResult.php b/src/Framework/Router/Result/ViewResult.php
new file mode 100644
index 00000000..9d74c086
--- /dev/null
+++ b/src/Framework/Router/Result/ViewResult.php
@@ -0,0 +1,27 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Router\Result;
+
+use App\Framework\Http\Status;
+use App\Framework\Meta\MetaData;
+use App\Framework\Router\ActionResult;
+
+final readonly class ViewResult implements ActionResult
+{
+    public function __construct(
+        public string $template,
+        public MetaData $metaData,
+        public array $data = [],
+        public Status $status = Status::OK,
+        #public string $layout = '',
+        public array $slots = [],
+        public ?string $controllerClass = null,
+        public ?object $model = null,
+    ) {}
+
+    /*public static function fromStrings():self
+    {
+
+    }*/
+}
diff --git a/src/Framework/Router/Result/WebSocketResult.php b/src/Framework/Router/Result/WebSocketResult.php
new file mode 100644
index 00000000..50315b38
--- /dev/null
+++ b/src/Framework/Router/Result/WebSocketResult.php
@@ -0,0 +1,130 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Router\Result;
+
+use App\Framework\Http\Status;
+use App\Framework\Router\ActionResult;
+
+final class WebSocketResult implements ActionResult
+{
+    /**
+     * @var callable|null Handler für neue Verbindungen
+     */
+    private $onConnect = null;
+
+    /**
+     * @var callable|null Handler für eingehende Nachrichten
+     */
+    private $onMessage = null;
+
+    /**
+     * @var callable|null Handler für geschlossene Verbindungen
+     */
+    private $onClose = null;
+
+    /**
+     * @var callable|null Handler für Fehler
+     */
+    private $onError = null;
+
+    /**
+     * @var array Unterstützte Subprotokolle
+     */
+    private array $subprotocols = [];
+
+    /**
+     * @var int Maximale Nachrichtengröße in Bytes
+     */
+    private int $maxMessageSize = 1048576; // 1MB
+
+    /**
+     * @var int Ping-Intervall in Sekunden
+     */
+    private int $pingInterval = 30;
+
+    public function __construct(
+        public readonly Status $status = Status::SWITCHING_PROTOCOLS,
+        public readonly array $headers = []
+    ) {}
+
+    /**
+     * Setzt den Handler für neue Verbindungen
+     *
+     * @param callable $handler function(WebSocketConnection $connection): void
+     */
+    public function onConnect(callable $handler): self
+    {
+        $this->onConnect = $handler;
+        return $this;
+    }
+
+    /**
+     * Setzt den Handler für eingehende Nachrichten
+     *
+     * @param callable $handler function(WebSocketConnection $connection, string $message): void
+     */
+    public function onMessage(callable $handler): self
+    {
+        $this->onMessage = $handler;
+        return $this;
+    }
+
+    /**
+     * Setzt den Handler für geschlossene Verbindungen
+     *
+     * @param callable $handler function(WebSocketConnection $connection, int $code, string $reason): void
+     */
+    public function onClose(callable $handler): self
+    {
+        $this->onClose = $handler;
+        return $this;
+    }
+
+    /**
+     * Setzt den Handler für Fehler
+     *
+     * @param callable $handler function(WebSocketConnection $connection, \Throwable $error): void
+     */
+    public function onError(callable $handler): self
+    {
+        $this->onError = $handler;
+        return $this;
+    }
+
+    /**
+     * Setzt unterstützte Subprotokolle
+     */
+    public function withSubprotocols(array $subprotocols): self
+    {
+        $this->subprotocols = $subprotocols;
+        return $this;
+    }
+
+    /**
+     * Setzt die maximale Nachrichtengröße
+     */
+    public function withMaxMessageSize(int $bytes): self
+    {
+        $this->maxMessageSize = $bytes;
+        return $this;
+    }
+
+    /**
+     * Setzt das Ping-Intervall
+     */
+    public function withPingInterval(int $seconds): self
+    {
+        $this->pingInterval = $seconds;
+        return $this;
+    }
+
+    // Getter
+    public function getOnConnect(): ?callable { return $this->onConnect; }
+    public function getOnMessage(): ?callable { return $this->onMessage; }
+    public function getOnClose(): ?callable { return $this->onClose; }
+    public function getOnError(): ?callable { return $this->onError; }
+    public function getSubprotocols(): array { return $this->subprotocols; }
+    public function getMaxMessageSize(): int { return $this->maxMessageSize; }
+    public function getPingInterval(): int { return $this->pingInterval; }
+}
diff --git a/src/Framework/Router/RouteCollection.php b/src/Framework/Router/RouteCollection.php
index df2a8425..9f7398fe 100644
--- a/src/Framework/Router/RouteCollection.php
+++ b/src/Framework/Router/RouteCollection.php
@@ -2,24 +2,63 @@
 
 namespace App\Framework\Router;
 
-final class RouteCollection
+use App\Framework\Core\Route;
+use App\Framework\Http\Method;
+use Countable;
+use Generator;
+
+final readonly class RouteCollection implements Countable
 {
-    /** @var array<string, array{static: array<string, callable>, dynamic: array<array{regex: string, handler: callable}>}> */
-    private array $routes;
+    /**
+     * @param array<string, array{static: array<string, callable>, dynamic: array<array{regex: string, handler: callable}>}> $routes
+     #* @param array<string, array{path: string, method: Method, handler: callable}> $namedRoutes
+     */
+    public function __construct(
+        private array $routes,
+        private array $namedRoutes = []
+    ) {}
 
-    public function __construct(array $routes) {
-        $this->routes = $routes;
+    public function getStatic(Method $method): array {
+        return $this->routes[$method->value]['static'] ?? [];
     }
 
-    public function getStatic(string $method): array {
-        return $this->routes[$method]['static'] ?? [];
+    public function getDynamic(Method $method): array {
+        return $this->routes[$method->value]['dynamic'] ?? [];
     }
 
-    public function getDynamic(string $method): array {
-        return $this->routes[$method]['dynamic'] ?? [];
+    public function has(Method $method): bool {
+        return isset($this->routes[$method->value]);
     }
 
-    public function has(string $method): bool {
-        return isset($this->routes[$method]);
+    public function getByMethod(Method $method): array {
+
+        return ($this->routes[$method->value]['dynamic'] + $this->routes[$method->value]['static']) ?? [];
+    }
+
+    public function getByName(string $name): ?Route
+    {
+        return $this->namedRoutes[$name] ?? null;
+    }
+
+    /**
+     * Gibt alle Named Routes zurück
+     *
+     * @return Generator<string, Route>
+     */
+    public function getAllNamedRoutes(): Generator
+    {
+        foreach ($this->namedRoutes as $name => $route) {
+            yield $name => $route;
+        }
+    }
+
+
+    public function hasName(string $name): bool {
+        return isset($this->namedRoutes[$name]);
+    }
+
+    public function count(): int
+    {
+        return count($this->routes);
     }
 }
diff --git a/src/Framework/Router/RouteContext.php b/src/Framework/Router/RouteContext.php
index 9022e9d5..559a8933 100644
--- a/src/Framework/Router/RouteContext.php
+++ b/src/Framework/Router/RouteContext.php
@@ -2,6 +2,7 @@
 
 namespace App\Framework\Router;
 
+use App\Framework\Http\Method;
 use Closure;
 
 final class RouteContext
@@ -16,8 +17,8 @@ final class RouteContext
 
     public function __construct(
         public readonly RouteMatch $match,
-        public readonly string $method,
-        public readonly string $path
+        public readonly Method     $method,
+        public readonly string     $path
     ) {}
 
     public function isSuccess(): bool
diff --git a/src/Framework/Router/RouteDispatcher.php b/src/Framework/Router/RouteDispatcher.php
index 2c02fbd4..fbcae35f 100644
--- a/src/Framework/Router/RouteDispatcher.php
+++ b/src/Framework/Router/RouteDispatcher.php
@@ -4,48 +4,58 @@ declare(strict_types=1);
 
 namespace App\Framework\Router;
 
-use App\Framework\Http\HttpResponse;
+use App\Framework\Core\DynamicRoute;
+use App\Framework\DI\DefaultContainer;
 use App\Framework\Http\Response;
-use App\Framework\Http\Status;
+use App\Framework\Http\Responses\NotFound;
+use App\Framework\Router\Result\ContentNegotiationResult;
 
-class RouteDispatcher
+final readonly class RouteDispatcher
 {
+    public function __construct(
+        private DefaultContainer   $container,
+        private ParameterProcessor $parameterProcessor
+    ) {}
+
+    /**
+     * Verarbeitet eine Route und führt den entsprechenden Controller-Action aus
+     */
     public function dispatch(RouteContext $routeContext): ActionResult|Response
     {
         $routeMatch = $routeContext->match;
 
         if ($routeMatch->isMatch()) {
-            $controller = $routeMatch->route->controller;
-            $action = $routeMatch->route->action;
-            $params = $routeMatch->route->params;
-
-            $params = $this->prepareParameters(...$params);
-
-            $obj = new $controller();
-            $result = $obj->$action(...$params);
-
-            // Hier könntest du z. B. Response-Objekte erwarten oder generieren:
-            if ($result instanceof Response || $result instanceof ActionResult) {
-                return $result;
-            }
+            return $this->executeController($routeMatch);
         }
 
-        // Fehlerbehandlung z.B. 404
-        return new HttpResponse(status: Status::NOT_FOUND, body: 'Nicht gefunden');
+        return new NotFound();
     }
 
-    public function prepareParameters(...$params): mixed
+    /**
+     * Führt die Controller-Action mit den aufbereiteten Parametern aus
+     */
+    private function executeController(RouteMatch $routeMatch): ActionResult|Response
     {
-        $parameters = [];
-        foreach ($params as $param) {
-            if ($param['isBuiltin'] === true) {
-                $parameters[] = $param['default'];
-            } else {
-                #Container!
-                var_dump($param['isBuiltin']);
-            }
+        $controller = $routeMatch->route->controller;
+        $action = $routeMatch->route->action;
+        $params = $routeMatch->route->parameters;
+
+        $queryParams = [];
+
+        if($routeMatch->route instanceof DynamicRoute) {
+            $queryParams = $routeMatch->route->paramValues;
         }
 
-        return $parameters;
+        $preparedParams = $this->parameterProcessor->prepareParameters($params, $queryParams);
+
+        $controllerInstance = $this->container->get($controller);
+        $result = $controllerInstance->$action(...$preparedParams);
+
+        if ($result instanceof Response || $result instanceof ActionResult) {
+            return $result;
+        }
+
+        // Wenn kein gültiges Result zurückgegeben wird
+        return new NotFound('Ungültige Antwort vom Controller');
     }
 }
diff --git a/src/Framework/Router/RouteMatchSuccess.php b/src/Framework/Router/RouteMatchSuccess.php
index bc877e0f..04e3f955 100644
--- a/src/Framework/Router/RouteMatchSuccess.php
+++ b/src/Framework/Router/RouteMatchSuccess.php
@@ -5,15 +5,13 @@ declare(strict_types=1);
 namespace App\Framework\Router;
 
 use App\Framework\Core\DynamicRoute;
+use App\Framework\Core\Route;
 use App\Framework\Core\StaticRoute;
 
 final readonly class RouteMatchSuccess implements RouteMatch
 {
-    #public string $controller;
-    #public string $action;
-    #public array  $params;
     public function __construct(
-        public DynamicRoute|StaticRoute $route
+        public Route $route
     ) {
     }
 
diff --git a/src/Framework/Router/RouteResponder.php b/src/Framework/Router/RouteResponder.php
index 70c52b75..429bb471 100644
--- a/src/Framework/Router/RouteResponder.php
+++ b/src/Framework/Router/RouteResponder.php
@@ -4,70 +4,99 @@ declare(strict_types=1);
 
 namespace App\Framework\Router;
 
+use App\Framework\Core\PathProvider;
+use App\Framework\DI\DefaultContainer;
 use App\Framework\Http\Headers;
 use App\Framework\Http\HttpResponse;
 use App\Framework\Http\Response;
-use App\Framework\View\Engine;
+use App\Framework\Http\Responses\SseResponse;
+use App\Framework\Http\Responses\WebSocketResponse;
+use App\Framework\Router\Result\FileResult;
+use App\Framework\Router\Result\JsonResult;
+use App\Framework\Router\Result\Redirect;
+use App\Framework\Router\Result\SseResult;
+use App\Framework\Router\Result\ViewResult;
+use App\Framework\Router\Result\WebSocketResult;
 use App\Framework\View\RenderContext;
+use App\Framework\View\Template;
 use App\Framework\View\TemplateRenderer;
+use App\Framework\View\TemplateRendererInitializer;
 
-readonly class RouteResponder
+final readonly class RouteResponder
 {
     public function __construct(
-        private TemplateRenderer $templateRenderer = new Engine()
-    ) {
-    }
+        private PathProvider     $pathProvider,
+        private DefaultContainer $container,
+        private TemplateRenderer $templateRenderer,
+    ) {}
 
-    public function respond(ActionResult $result): Response
+    public function respond(Response|ActionResult $result): Response
     {
-        $contentType = "text/html";
-
-        switch ($result->resultType) {
-            case ResultType::Html:
-                $body = $this->renderTemplate(
-                    $result->template,
-                    $result->data,
-                        $result->layout ?? null,
-                        $result->slots ?? [],
-                    $result->controllerClass
-                );
-
-                $contentType = "text/html";
-
-                break;
-            case ResultType::Json:
-                $body = json_encode(
-                    $result->data,
-                    JSON_THROW_ON_ERROR | JSON_UNESCAPED_UNICODE
-                );
-                $contentType = "application/json";
-
-                break;
-            case ResultType::Plain:
-                $body = $result->data['text'] ?? '';
-                $contentType = "text/plain";
-                break;
-            default:
-                throw new \RuntimeException("Unknown result type: {$result->resultType}");
+        if($result instanceof Response) {
+            return $result;
         }
 
-        return new HttpResponse(
-            status: $result->status,
-            headers: new Headers()->with('Content-Type', $contentType),  //['Content-Type' => $contentType],
-            body: $body
-        );
+        return match(true) {
+            $result instanceof ViewResult => new HttpResponse(
+                status: $result->status,
+                body: $this->renderTemplate(
+                    new RenderContext(
+                        template: $result->model ? $this->resolveTemplate($result->model) : $result->template,
+                        metaData: $result->metaData,
+                        data: $result->model ? get_object_vars($result->model) + $result->data : $result->data,
+                        layout: '',
+                        slots: $result->slots
+                    )
+                )
+            ),
+            $result instanceof JsonResult => new HttpResponse(
+                status : $result->status,
+                headers: new Headers()->with('Content-Type', 'application/json'),
+                body   : json_encode($result->data),
+            ),
+            $result instanceof Redirect => new HttpResponse(
+                status: $result->status,
+                headers: new Headers()->with('Location', $result->target)
+            ),
+            $result instanceof SseResult => new SseResponse($result, $result->callback),
+            $result instanceof WebSocketResult => $this->createWebSocketResponse($result),
+            $result instanceof FileResult => new HttpResponse(
+                #headers: new Headers()->with('Content-Type', $result->mimeType),
+                body: $result->filePath
+            ),
+
+            default => throw new \RuntimeException('Unbekanntes Ergebnisobjekt: ' . get_class($result)),
+        };
     }
 
-    private function renderTemplate(string $template, array $data, ?string $layout, array $slots = [], ?string $controllerName = null): string
+    private function createWebSocketResponse(WebSocketResult $result): WebSocketResponse
     {
-        $context = new RenderContext(
-            template: $template,
-            data: $data,
-            layout: $layout,
-            slots: $slots,
-            controllerClass: $controllerName
-        );
+        // WebSocket-Key aus Request-Headers abrufen
+        $websocketKey = $_SERVER['HTTP_SEC_WEBSOCKET_KEY'] ?? '';
 
+        return new WebSocketResponse($result, $websocketKey);
+    }
+
+    private function renderTemplate(RenderContext $context): string
+    {
         return $this->templateRenderer->render($context);
     }
+
+    private function resolveTemplate(?object $model):string
+    {
+        if($model === null) {
+            return 'test';
+        }
+
+        $ref = new \ReflectionClass($model);
+        $attrs = $ref->getAttributes(Template::class);
+        if ($attrs === []) {
+            return 'test';
+            #throw new \RuntimeException("Fehlendes #[Template] Attribut in {$ref->getName()}");
+        }
+
+        /** @var Template $attr */
+        $attr = $attrs[0]->newInstance();
+        return $attr->path;
+    }
 }
diff --git a/src/Framework/Router/RouterSetup.php b/src/Framework/Router/RouterSetup.php
new file mode 100644
index 00000000..f70ad9b3
--- /dev/null
+++ b/src/Framework/Router/RouterSetup.php
@@ -0,0 +1,57 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Router;
+
+use App\Framework\Attributes\Route;
+use App\Framework\Core\PathProvider;
+use App\Framework\Core\RouteCache;
+use App\Framework\Core\RouteCompiler;
+use App\Framework\DI\DefaultContainer;
+use App\Framework\DI\Initializer;
+use App\Framework\Discovery\Results\DiscoveryResults;
+
+/**
+ * Verantwortlich für die Einrichtung des Routers
+ */
+final readonly class RouterSetup
+{
+    public function __construct(
+        private DefaultContainer $container,
+        private PathProvider     $pathProvider,
+        private RouteCompiler    $routeCompiler,
+        private DiscoveryResults $results,
+    ) {}
+
+    /**
+     * Richtet den Router basierend auf den verarbeiteten Attributen ein
+     */
+    #[Initializer]
+    public function __invoke(): HttpRouter
+    {
+        #$routeCache = new RouteCache($this->pathProvider->getCachePath('routes.cache.php'));
+
+        if ($this->results->has(Route::class)) {
+            $discoveryRoutes = $this->results->get(Route::class);
+
+            // DIREKT zu optimierten Routen
+            $optimizedRoutes = $this->routeCompiler->compileOptimized($discoveryRoutes);
+
+            // Cache speichern
+            #$routeCache->save($optimizedRoutes);
+
+            // FULL COMMIT: Nur CompiledRoutes
+
+        } else {
+            $optimizedRoutes = $this->routeCompiler->compileOptimized([]);
+        }
+
+        $router = new HttpRouter($optimizedRoutes);
+
+        $this->container->bind(CompiledRoutes::class, $optimizedRoutes);
+        $this->container->bind(HttpRouter::class, $router);
+
+        return $router;
+    }
+}
diff --git a/src/Framework/Router/UrlGenerator.php b/src/Framework/Router/UrlGenerator.php
new file mode 100644
index 00000000..ffdda940
--- /dev/null
+++ b/src/Framework/Router/UrlGenerator.php
@@ -0,0 +1,173 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Router;
+
+use App\Framework\Attributes\Singleton;
+use App\Framework\Core\Route;
+use App\Framework\Http\Request;
+use App\Framework\Router\Exception\RouteNotFound;
+
+/**
+ * Service zur Generierung von URLs basierend auf Named Routes
+ */
+#[Singleton]
+final readonly class UrlGenerator
+{
+    #private RouteCollection $routes;
+
+    public function __construct(
+        HttpRouter $router,
+        private Request $request,
+        private CompiledRoutes $routes,
+    ) {
+        #$this->routes = $router->routes;
+    }
+
+    /**
+     * Generiert eine URL für eine Named Route
+     *
+     * @param string $name Name der Route
+     * @param array<string, mixed> $parameters Parameter für dynamische Routes
+     * @param bool $absolute Ob eine absolute URL generiert werden soll
+     * @return string Generierte URL
+     * @throws RouteNotFound Wenn die Route nicht gefunden wird
+     */
+    public function route(string $name, array $parameters = [], bool $absolute = false): string
+    {
+        $route = $this->routes->getNamedRoute($name);
+
+        if ($route === null) {
+            throw new RouteNotFound("Route with name '{$name}' not found.");
+        }
+
+        $url = $this->buildUrl($route->path, $parameters);
+
+        if ($absolute) {
+            return $this->makeAbsolute($url);
+        }
+
+        return $url;
+    }
+
+    /**
+     * Generiert eine absolute URL für eine Named Route
+     *
+     * @param string $name Name der Route
+     * @param array<string, mixed> $parameters Parameter für dynamische Routes
+     * @return string Absolute URL
+     */
+    public function absoluteRoute(string $name, array $parameters = []): string
+    {
+        return $this->route($name, $parameters, true);
+    }
+
+    /**
+     * Erstellt eine URL basierend auf dem aktuellen Request mit geänderten Parametern
+     *
+     * @param array<string, mixed> $parameters Query-Parameter
+     * @param bool $absolute Ob eine absolute URL generiert werden soll
+     * @return string Generierte URL
+     */
+    public function current(array $parameters = [], bool $absolute = false): string
+    {
+        $url = $this->request->path;
+
+        if (!empty($parameters)) {
+            $url .= '?' . http_build_query(array_merge(
+                $this->request->query->all(),
+                $parameters
+            ));
+        } elseif (!empty($this->request->query->all())) {
+            $url .= '?' . http_build_query($this->request->query->all());
+        }
+
+        if ($absolute) {
+            return $this->makeAbsolute($url);
+        }
+
+        return $url;
+    }
+
+    /**
+     * Prüft, ob die aktuelle Route mit dem gegebenen Namen übereinstimmt
+     */
+    public function isCurrentRoute(string $name): bool
+    {
+        try {
+            $route = $this->routes->getByName($name);
+            return $route !== null && $route->path === $this->request->path;
+        } catch (RouteNotFound) {
+            return false;
+        }
+    }
+
+    /**
+     * Erstellt eine URL aus einem Pfad-Template und Parametern
+     *
+     * @param string $path Pfad-Template (z.B. "/user/{id}/posts/{slug}")
+     * @param array<string, mixed> $parameters Parameter-Werte
+     * @return string Fertige URL
+     */
+    private function buildUrl(string $path, array $parameters): string
+    {
+        $url = $path;
+        $queryParams = [];
+
+        // Ersetze Pfad-Parameter
+        foreach ($parameters as $key => $value) {
+            $placeholder = "{{$key}}";
+            if (str_contains($url, $placeholder)) {
+                $url = str_replace($placeholder, (string)$value, $url);
+                unset($parameters[$key]);
+            } else {
+                // Übrige Parameter werden zu Query-Parametern
+                $queryParams[$key] = $value;
+            }
+        }
+
+        // Prüfe auf nicht ersetzte Platzhalter
+        if (preg_match('/\{[^}]+\}/', $url)) {
+            throw new \InvalidArgumentException(
+                "Missing required parameters for route. URL: {$url}"
+            );
+        }
+
+        // Füge Query-Parameter hinzu
+        if (!empty($queryParams)) {
+            $url .= '?' . http_build_query($queryParams);
+        }
+
+        return $url;
+    }
+
+    /**
+     * Macht eine relative URL zu einer absoluten URL
+     */
+    private function makeAbsolute(string $url): string
+    {
+        $scheme = $this->request->server->isHttps() ? 'https' : 'http';
+        $host = $this->request->server->getHttpHost();
+
+        return "{$scheme}://{$host}{$url}";
+    }
+
+    /**
+     * Generiert eine URL für eine Asset-Datei
+     *
+     * @param string $asset Pfad zur Asset-Datei
+     * @param bool $absolute Ob eine absolute URL generiert werden soll
+     * @return string Asset-URL
+     */
+    public function asset(string $asset, bool $absolute = false): string
+    {
+        $url = '/assets/' . ltrim($asset, '/');
+
+        if ($absolute) {
+            return $this->makeAbsolute($url);
+        }
+
+        return $url;
+    }
+}
diff --git a/src/Framework/Sitemap/SitemapEntry.php b/src/Framework/Sitemap/SitemapEntry.php
new file mode 100644
index 00000000..041b6dfc
--- /dev/null
+++ b/src/Framework/Sitemap/SitemapEntry.php
@@ -0,0 +1,27 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Sitemap;
+
+use DateTimeImmutable;
+
+final readonly class SitemapEntry
+{
+    public function __construct(
+        public string $url,
+        public DateTimeImmutable $lastmod,
+        public string $changefreq = 'monthly',
+        public float $priority = 0.5
+    ) {}
+
+    public function toXml(): string
+    {
+        return sprintf(
+            '<url><loc>%s</loc><lastmod>%s</lastmod><changefreq>%s</changefreq><priority>%.1f</priority></url>',
+            htmlspecialchars($this->url),
+            $this->lastmod->format('Y-m-d'),
+            $this->changefreq,
+            $this->priority
+        );
+    }
+}
diff --git a/src/Framework/Sitemap/SitemapGenerator.php b/src/Framework/Sitemap/SitemapGenerator.php
new file mode 100644
index 00000000..611fa4a9
--- /dev/null
+++ b/src/Framework/Sitemap/SitemapGenerator.php
@@ -0,0 +1,100 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Sitemap;
+
+use App\Framework\Attributes\Singleton;
+use App\Framework\Core\Route;
+use App\Framework\Http\Method;
+use App\Framework\Router\RouteCollection;
+use App\Framework\Router\UrlGenerator;
+use Generator;
+
+#[Singleton]
+final readonly class SitemapGenerator
+{
+    public function __construct(
+        private RouteCollection $routes,
+        private UrlGenerator $urlGenerator
+    ) {}
+
+    /**
+     * Generiert Sitemap-URLs aus allen verfügbaren Named Routes
+     *
+     * @return Generator<SitemapEntry>
+     */
+    public function generateFromRoutes(): Generator
+    {
+        foreach ($this->getPublicRoutes() as $route) {
+            if ($this->isStaticRoute($route)) {
+                yield new SitemapEntry(
+                    url: $this->urlGenerator->absoluteRoute($route->name),
+                    lastmod: new \DateTimeImmutable(),
+                    changefreq: $this->determineChangeFreq($route),
+                    priority: $this->determinePriority($route)
+                );
+            }
+        }
+    }
+
+    /**
+     * Holt alle öffentlichen Named Routes
+     */
+    private function getPublicRoutes(): Generator
+    {
+        // Hier müssen Sie eine Methode in RouteCollection hinzufügen
+        foreach ($this->routes->getAllNamedRoutes() as $name => $route) {
+
+            // Nur GET-Routen für Sitemap: Named Routes sind aktuell immer nur Routes mit GET Methode
+            if (/*$this->supportsMethod($route, Method::GET) &&*/
+                !$this->isExcludedFromSitemap($route)) {
+                yield $route;
+            }
+        }
+    }
+
+    private function isStaticRoute(Route $route): bool
+    {
+        // Prüft ob Route keine Parameter benötigt
+        return !str_contains($route->path, '{');
+    }
+
+    private function supportsMethod(Route $route, Method $method): bool
+    {
+        return in_array($method->value, $route->method->value ?? [], true);
+    }
+
+    private function isExcludedFromSitemap(Route $route): bool
+    {
+        // Admin/API-Routen ausschließen
+        $excludePatterns = ['/admin', '/api', '/auth'];
+
+        foreach ($excludePatterns as $pattern) {
+            if (str_starts_with($route->path, $pattern)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    private function determineChangeFreq(Route $route): string
+    {
+        // Basierend auf Route-Name oder Pfad
+        return match (true) {
+            str_contains($route->path, '/blog') => 'weekly',
+            str_contains($route->path, '/news') => 'daily',
+            $route->name === 'home' => 'weekly',
+            default => 'monthly'
+        };
+    }
+
+    private function determinePriority(Route $route): float
+    {
+        return match ($route->name) {
+            'home' => 1.0,
+            'about', 'contact' => 0.8,
+            default => 0.5
+        };
+    }
+}
diff --git a/src/Framework/Smartlinks/Actions/ActionRegistry.php b/src/Framework/Smartlinks/Actions/ActionRegistry.php
new file mode 100644
index 00000000..459ff85c
--- /dev/null
+++ b/src/Framework/Smartlinks/Actions/ActionRegistry.php
@@ -0,0 +1,33 @@
+<?php
+
+namespace App\Framework\Smartlinks\Actions;
+
+use App\Framework\Smartlinks\TokenAction;
+
+interface ActionRegistry
+{
+    /**
+     * Register an action
+     */
+    public function register(SmartlinkAction $action): void;
+
+    /**
+     * Get an action by name
+     */
+    public function get(TokenAction $action): ?SmartlinkAction;
+
+    /**
+     * Check if an action is registered
+     */
+    public function has(TokenAction $action): bool;
+
+    /**
+     * Get all registered actions
+     */
+    public function getAll(): array;
+
+    /**
+     * Unregister an action
+     */
+    public function unregister(TokenAction $action): void;
+}
diff --git a/src/Framework/Smartlinks/Actions/ActionResult.php b/src/Framework/Smartlinks/Actions/ActionResult.php
new file mode 100644
index 00000000..a77061c7
--- /dev/null
+++ b/src/Framework/Smartlinks/Actions/ActionResult.php
@@ -0,0 +1,43 @@
+<?php
+
+namespace App\Framework\Smartlinks\Actions;
+
+final readonly class ActionResult
+{
+    public function __construct(
+        public bool $success,
+        public string $message = '',
+        public array $data = [],
+        public ?string $redirectUrl = null,
+        public array $errors = []
+    ) {}
+
+    public static function success(string $message = '', array $data = [], ?string $redirectUrl = null): self
+    {
+        return new self(
+            success: true,
+            message: $message,
+            data: $data,
+            redirectUrl: $redirectUrl
+        );
+    }
+
+    public static function failure(string $message, array $errors = []): self
+    {
+        return new self(
+            success: false,
+            message: $message,
+            errors: $errors
+        );
+    }
+
+    public function isSuccess(): bool
+    {
+        return $this->success;
+    }
+
+    public function hasRedirect(): bool
+    {
+        return $this->redirectUrl !== null;
+    }
+}
diff --git a/src/Framework/Smartlinks/Actions/DefaultActionRegistry.php b/src/Framework/Smartlinks/Actions/DefaultActionRegistry.php
new file mode 100644
index 00000000..98c765d2
--- /dev/null
+++ b/src/Framework/Smartlinks/Actions/DefaultActionRegistry.php
@@ -0,0 +1,36 @@
+<?php
+
+namespace App\Framework\Smartlinks\Actions;
+
+use App\Framework\Smartlinks\TokenAction;
+
+final class DefaultActionRegistry implements ActionRegistry
+{
+    /** @var SmartlinkAction[] */
+    private array $actions = [];
+
+    public function register(SmartlinkAction $action): void
+    {
+        $this->actions[$action->getName()] = $action;
+    }
+
+    public function get(TokenAction $action): ?SmartlinkAction
+    {
+        return $this->actions[$action->name] ?? null;
+    }
+
+    public function has(TokenAction $action): bool
+    {
+        return isset($this->actions[$action->name]);
+    }
+
+    public function getAll(): array
+    {
+        return $this->actions;
+    }
+
+    public function unregister(TokenAction $action): void
+    {
+        unset($this->actions[$action->name]);
+    }
+}
diff --git a/src/Framework/Smartlinks/Actions/DocumentAccessAction.php b/src/Framework/Smartlinks/Actions/DocumentAccessAction.php
new file mode 100644
index 00000000..1716256e
--- /dev/null
+++ b/src/Framework/Smartlinks/Actions/DocumentAccessAction.php
@@ -0,0 +1,51 @@
+<?php
+
+namespace App\Framework\Smartlinks\Actions;
+
+use App\Framework\Smartlinks\SmartlinkData;
+use App\Framework\Smartlinks\TokenConfig;
+
+final readonly class DocumentAccessAction implements SmartlinkAction
+{
+    public function getName(): string
+    {
+        return 'document_access';
+    }
+
+    public function getDefaultConfig(): TokenConfig
+    {
+        return new TokenConfig(
+            expiryHours: 72, // 3 days
+            oneTimeUse: false, // Can be accessed multiple times
+            maxUses: 10,
+            requireSecureContext: false
+        );
+    }
+
+    public function validatePayload(array $payload): bool
+    {
+        return !empty($payload['document_id']) &&
+            in_array($payload['access_level'], ['read', 'download', 'edit']);
+    }
+
+    public function execute(SmartlinkData $smartlinkData, array $context = []): ActionResult
+    {
+        $payload = $smartlinkData->payload;
+
+        // Document access logic
+        return ActionResult::success(
+            message: "Document access granted",
+            data: [
+                'document_id' => $payload['document_id'],
+                'access_level' => $payload['access_level'],
+                'download_url' => "/documents/{$payload['document_id']}/download",
+                'expires_at' => $smartlinkData->expiresAt->format('Y-m-d H:i:s')
+            ]
+        );
+    }
+
+    public function getRequiredPermissions(): array
+    {
+        return ['documents.access'];
+    }
+}
diff --git a/src/Framework/Smartlinks/Actions/EmailVerificationAction.php b/src/Framework/Smartlinks/Actions/EmailVerificationAction.php
new file mode 100644
index 00000000..c33a820e
--- /dev/null
+++ b/src/Framework/Smartlinks/Actions/EmailVerificationAction.php
@@ -0,0 +1,54 @@
+<?php
+
+namespace App\Framework\Smartlinks\Actions;
+
+use App\Framework\Smartlinks\SmartlinkData;
+use App\Framework\Smartlinks\TokenConfig;
+use DateTimeImmutable;
+final readonly class EmailVerificationAction implements SmartlinkAction
+{
+    public function getName(): string
+    {
+        return 'email_verification';
+    }
+
+    public function getDefaultConfig(): TokenConfig
+    {
+        return new TokenConfig(
+            expiryHours: 24,
+            oneTimeUse: true,
+            maxUses: 1,
+            requireSecureContext: true
+        );
+    }
+
+    public function validatePayload(array $payload): bool
+    {
+        return !empty($payload['email']) &&
+            !empty($payload['user_id']) &&
+            filter_var($payload['email'], FILTER_VALIDATE_EMAIL);
+    }
+
+    public function execute(SmartlinkData $smartlinkData, array $context = []): ActionResult
+    {
+        $payload = $smartlinkData->payload;
+
+        // Email verification logic would go here
+        // For now, just a simple success response
+
+        return ActionResult::success(
+            message: "Email {$payload['email']} successfully verified",
+            data: [
+                'user_id' => $payload['user_id'],
+                'email' => $payload['email'],
+                'verified_at' => new DateTimeImmutable()
+            ],
+            redirectUrl: '/dashboard'
+        );
+    }
+
+    public function getRequiredPermissions(): array
+    {
+        return []; // No special permissions needed for email verification
+    }
+}
diff --git a/src/Framework/Smartlinks/Actions/GenericDataAccessAction.php b/src/Framework/Smartlinks/Actions/GenericDataAccessAction.php
new file mode 100644
index 00000000..d8bb84b0
--- /dev/null
+++ b/src/Framework/Smartlinks/Actions/GenericDataAccessAction.php
@@ -0,0 +1,45 @@
+<?php
+
+namespace App\Framework\Smartlinks\Actions;
+
+use App\Framework\Smartlinks\SmartlinkData;
+use App\Framework\Smartlinks\TokenConfig;
+
+final readonly class GenericDataAccessAction implements SmartlinkAction
+{
+    public function __construct(
+        private string $actionName,
+        private TokenConfig $config,
+        private array $requiredPermissions = []
+    ) {}
+
+    public function getName(): string
+    {
+        return $this->actionName;
+    }
+
+    public function getDefaultConfig(): TokenConfig
+    {
+        return $this->config;
+    }
+
+    public function validatePayload(array $payload): bool
+    {
+        // Generic validation - just check that payload is not empty
+        return !empty($payload);
+    }
+
+    public function execute(SmartlinkData $smartlinkData, array $context = []): ActionResult
+    {
+        // Generic execution - just return the payload data
+        return ActionResult::success(
+            message: "Action '{$this->actionName}' executed successfully",
+            data: $smartlinkData->payload
+        );
+    }
+
+    public function getRequiredPermissions(): array
+    {
+        return $this->requiredPermissions;
+    }
+}
diff --git a/src/Framework/Smartlinks/Actions/PasswordResetAction.php b/src/Framework/Smartlinks/Actions/PasswordResetAction.php
new file mode 100644
index 00000000..d37d3b25
--- /dev/null
+++ b/src/Framework/Smartlinks/Actions/PasswordResetAction.php
@@ -0,0 +1,54 @@
+<?php
+
+namespace App\Framework\Smartlinks\Actions;
+
+use App\Framework\Smartlinks\SmartlinkData;
+use App\Framework\Smartlinks\TokenConfig;
+
+final readonly class PasswordResetAction implements SmartlinkAction
+{
+    public function getName(): string
+    {
+        return 'password_reset';
+    }
+
+    public function getDefaultConfig(): TokenConfig
+    {
+        return new TokenConfig(
+            expiryHours: 1, // Short expiry for security
+            oneTimeUse: true,
+            maxUses: 1,
+            requireSecureContext: true
+        );
+    }
+
+    public function validatePayload(array $payload): bool
+    {
+        return !empty($payload['user_id']) &&
+            !empty($payload['email']) &&
+            filter_var($payload['email'], FILTER_VALIDATE_EMAIL);
+    }
+
+    public function execute(SmartlinkData $smartlinkData, array $context = []): ActionResult
+    {
+        $payload = $smartlinkData->payload;
+
+        // Password reset form would be shown here
+        // Return data needed for the password reset form
+
+        return ActionResult::success(
+            message: "Password reset form ready",
+            data: [
+                'user_id' => $payload['user_id'],
+                'email' => $payload['email'],
+                'form_action' => '/password/reset/submit',
+                'csrf_token' => $context['csrf_token'] ?? null
+            ]
+        );
+    }
+
+    public function getRequiredPermissions(): array
+    {
+        return [];
+    }
+}
diff --git a/src/Framework/Smartlinks/Actions/SmartlinkAction.php b/src/Framework/Smartlinks/Actions/SmartlinkAction.php
new file mode 100644
index 00000000..7ee1f53a
--- /dev/null
+++ b/src/Framework/Smartlinks/Actions/SmartlinkAction.php
@@ -0,0 +1,34 @@
+<?php
+
+namespace App\Framework\Smartlinks\Actions;
+
+use App\Framework\Smartlinks\SmartlinkData;
+use App\Framework\Smartlinks\TokenConfig;
+
+interface SmartlinkAction
+{
+    /**
+     * Get the action name
+     */
+    public function getName(): string;
+
+    /**
+     * Get default configuration for this action
+     */
+    public function getDefaultConfig(): TokenConfig;
+
+    /**
+     * Validate the payload for this action
+     */
+    public function validatePayload(array $payload): bool;
+
+    /**
+     * Execute the action
+     */
+    public function execute(SmartlinkData $smartlinkData, array $context = []): ActionResult;
+
+    /**
+     * Get required permissions/roles for this action
+     */
+    public function getRequiredPermissions(): array;
+}
diff --git a/src/Framework/Smartlinks/Commands/ExecuteSmartlinkCommand.php b/src/Framework/Smartlinks/Commands/ExecuteSmartlinkCommand.php
new file mode 100644
index 00000000..b5eadbda
--- /dev/null
+++ b/src/Framework/Smartlinks/Commands/ExecuteSmartlinkCommand.php
@@ -0,0 +1,13 @@
+<?php
+
+namespace App\Framework\Smartlinks\Commands;
+
+use App\Framework\Smartlinks\SmartLinkToken;
+
+final readonly class ExecuteSmartlinkCommand
+{
+    public function __construct(
+        public SmartlinkToken $token,
+        public array $context = []
+    ) {}
+}
diff --git a/src/Framework/Smartlinks/Commands/ExecuteSmartlinkHandler.php b/src/Framework/Smartlinks/Commands/ExecuteSmartlinkHandler.php
new file mode 100644
index 00000000..d5f1b41a
--- /dev/null
+++ b/src/Framework/Smartlinks/Commands/ExecuteSmartlinkHandler.php
@@ -0,0 +1,42 @@
+<?php
+
+namespace App\Framework\Smartlinks\Commands;
+
+use App\Framework\CommandBus\CommandHandler;
+use App\Framework\Smartlinks\Actions\ActionRegistry;
+use App\Framework\Smartlinks\Actions\ActionResult;
+use App\Framework\Smartlinks\Services\SmartlinkService;
+
+final readonly class ExecuteSmartlinkHandler
+{
+    public function __construct(
+        private SmartlinkService $smartlinkService,
+        private ActionRegistry $actionRegistry
+    ) {}
+
+    #[CommandHandler]
+    public function handle(ExecuteSmartlinkCommand $command): ActionResult
+    {
+        // Validate token
+        $smartlinkData = $this->smartlinkService->validate($command->token);
+        if (!$smartlinkData) {
+            return ActionResult::failure('Invalid or expired smartlink');
+        }
+
+        // Get action
+        $action = $this->actionRegistry->get($smartlinkData->action);
+        if (!$action) {
+            return ActionResult::failure('Unknown action: ' . $smartlinkData->action);
+        }
+
+        // Execute action
+        $result = $action->execute($smartlinkData, $command->context);
+
+        // Mark as used if one-time use
+        if ($smartlinkData->oneTimeUse && $result->isSuccess()) {
+            $this->smartlinkService->markAsUsed($command->token);
+        }
+
+        return $result;
+    }
+}
diff --git a/src/Framework/Smartlinks/Commands/GenerateSmartlinkCommand.php b/src/Framework/Smartlinks/Commands/GenerateSmartlinkCommand.php
new file mode 100644
index 00000000..86f54a24
--- /dev/null
+++ b/src/Framework/Smartlinks/Commands/GenerateSmartlinkCommand.php
@@ -0,0 +1,19 @@
+<?php
+
+namespace App\Framework\Smartlinks\Commands;
+
+use App\Framework\Smartlinks\TokenAction;
+use App\Framework\Smartlinks\TokenConfig;
+
+final readonly class GenerateSmartlinkCommand
+{
+    public function __construct(
+        public TokenAction $action,
+        public array $payload,
+        public ?TokenConfig $config = null,
+        public ?string $baseUrl = null,
+        public ?string $createdByIp = null,
+        public ?string $userAgent = null
+    ) {}
+}
+
diff --git a/src/Framework/Smartlinks/Commands/GenerateSmartlinkHandler.php b/src/Framework/Smartlinks/Commands/GenerateSmartlinkHandler.php
new file mode 100644
index 00000000..76982f5a
--- /dev/null
+++ b/src/Framework/Smartlinks/Commands/GenerateSmartlinkHandler.php
@@ -0,0 +1,46 @@
+<?php
+
+namespace App\Framework\Smartlinks\Commands;
+
+use App\Framework\CommandBus\CommandHandler;
+use App\Framework\Smartlinks\Actions\ActionRegistry;
+use App\Framework\Smartlinks\Services\SmartlinkService;
+
+final readonly class GenerateSmartlinkHandler
+{
+    public function __construct(
+        private SmartlinkService $smartlinkService,
+        private ActionRegistry $actionRegistry
+    ) {}
+
+    #[CommandHandler]
+    public function handle(GenerateSmartlinkCommand $command): string
+    {
+        // Validate action exists
+        $action = $this->actionRegistry->get($command->action);
+        if (!$action) {
+            throw new \InvalidArgumentException("Unknown action: {$command->action}");
+        }
+
+        // Validate payload
+        if (!$action->validatePayload($command->payload)) {
+            throw new \InvalidArgumentException("Invalid payload for action: {$command->action}");
+        }
+
+        // Use action's default config if none provided
+        $config = $command->config ?? $action->getDefaultConfig();
+
+        // Generate token
+        $token = $this->smartlinkService->generate(
+            action: $command->action,
+            payload: $command->payload,
+            config: $config,
+            createdByIp: $command->createdByIp,
+            userAgent: $command->userAgent
+        );
+
+        // Build full URL
+        $baseUrl = $command->baseUrl ?? '';
+        return rtrim($baseUrl, '/') . '/smartlink/' . $token;
+    }
+}
diff --git a/src/Framework/Smartlinks/Services/CacheSmartLinkService.php b/src/Framework/Smartlinks/Services/CacheSmartLinkService.php
new file mode 100644
index 00000000..50b51f84
--- /dev/null
+++ b/src/Framework/Smartlinks/Services/CacheSmartLinkService.php
@@ -0,0 +1,150 @@
+<?php
+
+namespace App\Framework\Smartlinks\Services;
+
+use App\Framework\Cache\Cache;
+use App\Framework\DateTime\Clock;
+use App\Framework\Smartlinks\SmartlinkData;
+use App\Framework\Smartlinks\SmartLinkToken;
+use App\Framework\Smartlinks\TokenAction;
+use App\Framework\Smartlinks\TokenConfig;
+use App\Framework\Ulid\UlidGenerator;
+use DateTimeImmutable;
+
+final readonly class CacheSmartLinkService implements SmartlinkService
+{
+    public function __construct(
+        private Cache $cache,
+        private UlidGenerator $ulidGenerator,
+        private Clock $clock
+    ) {}
+
+    public function generate(
+        TokenAction $action,
+        array                   $payload,
+        ?TokenConfig            $config = null,
+        ?string                 $createdByIp = null,
+        ?string                 $userAgent = null
+    ): SmartLinkToken
+    {
+        $config ??= new TokenConfig();
+        $id = $this->ulidGenerator->generate($this->clock);
+        $now = new DateTimeImmutable();
+
+        $smartlinkData = new SmartlinkData(
+            id: $id,
+            action: $action,
+            payload: $payload,
+            expiresAt: $config->getExpiryDateTime(),
+            createdAt: $now,
+            oneTimeUse: $config->oneTimeUse,
+            createdByIp: $createdByIp,
+            userAgent: $userAgent
+        );
+
+        $token = new SmartlinkToken($id);
+
+        // In Cache speichern
+        $this->cache->set(
+            "smartlink:{$id}",
+            $this->serializeData($smartlinkData),
+            $config->expiryHours * 3600
+        );
+
+        return $token;
+    }
+
+    public function validate(SmartlinkToken $token): ?SmartlinkData
+    {
+        $data = $this->cache->get("smartlink:{$token->value}");
+
+        if (!$data->isHit) {
+            return null;
+        }
+
+        $smartlinkData = $this->deserializeData($data->value);
+
+        return $smartlinkData->isValid() ? $smartlinkData : null;
+    }
+
+    public function markAsUsed(SmartlinkToken $token): void
+    {
+        $data = $this->validate($token);
+        if ($data) {
+            $updatedData = $data->withUsed(new DateTimeImmutable());
+            $this->cache->set(
+                "smartlink:{$token->value}",
+                $this->serializeData($updatedData),
+                $data->getRemainingTime()->h * 3600
+            );
+        }
+    }
+
+    public function revoke(SmartlinkToken $token): void
+    {
+        $this->cache->forget("smartlink:{$token->value}");
+    }
+
+    public function exists(SmartlinkToken $token): bool
+    {
+        return $this->cache->has("smartlink:{$token->value}");
+    }
+
+    public function getActiveTokens(int $limit = 100): array
+    {
+        // Cache-Keys durchsuchen
+        $pattern = "smartlink:*";
+        $keys = $this->cache->getKeys($pattern) ?? [];
+
+        $tokens = [];
+        foreach (array_slice($keys, 0, $limit) as $key) {
+            $data = $this->cache->get($key);
+            if ($data->isHit) {
+                $smartlinkData = $this->deserializeData($data->value);;
+                if ($smartlinkData->isValid()) {
+                    $tokens[] = $smartlinkData;
+                }
+            }
+        }
+
+        return $tokens;
+    }
+
+    public function cleanupExpired(): int
+    {
+        // Bei Cache-basierter Implementation werden expired Items automatisch entfernt
+        return 0;
+    }
+
+    private function serializeData(SmartlinkData $data): array
+    {
+        return [
+            'id' => $data->id,
+            'action' => $data->action->name,
+            'payload' => $data->payload,
+            'expires_at' => $data->expiresAt->format('Y-m-d H:i:s'),
+            'created_at' => $data->createdAt->format('Y-m-d H:i:s'),
+            'one_time_use' => $data->oneTimeUse,
+            'created_by_ip' => $data->createdByIp,
+            'user_agent' => $data->userAgent,
+            'is_used' => $data->isUsed,
+            'used_at' => $data->usedAt?->format('Y-m-d H:i:s')
+        ];
+    }
+
+    private function deserializeData(array $data): SmartlinkData
+    {
+        return new SmartlinkData(
+            id: $data['id'],
+            action: new TokenAction($data['action']),
+            payload: $data['payload'],
+            expiresAt: new DateTimeImmutable($data['expires_at']),
+            createdAt: new DateTimeImmutable($data['created_at']),
+            oneTimeUse: $data['one_time_use'],
+            createdByIp: $data['created_by_ip'],
+            userAgent: $data['user_agent'],
+            isUsed: $data['is_used'],
+            usedAt: $data['used_at'] ? new DateTimeImmutable($data['used_at']) : null
+        );
+    }
+}
diff --git a/src/Framework/Smartlinks/Services/InMemorySmartLinkService.php b/src/Framework/Smartlinks/Services/InMemorySmartLinkService.php
new file mode 100644
index 00000000..39ad0fe0
--- /dev/null
+++ b/src/Framework/Smartlinks/Services/InMemorySmartLinkService.php
@@ -0,0 +1,103 @@
+<?php
+
+namespace App\Framework\Smartlinks\Services;
+
+use App\Framework\DateTime\Clock;
+use App\Framework\Smartlinks\SmartlinkData;
+use App\Framework\Smartlinks\SmartLinkToken;
+use App\Framework\Smartlinks\TokenAction;
+use App\Framework\Smartlinks\TokenConfig;
+use App\Framework\Ulid\UlidGenerator;
+
+final class InMemorySmartLinkService implements SmartlinkService
+{
+    private array $tokens = [];
+
+    public function __construct(
+        private readonly UlidGenerator $ulidGenerator,
+        private readonly Clock $clock
+    ) {}
+
+    public function generate(
+        TokenAction $action,
+        array                   $payload,
+        ?TokenConfig            $config = null,
+        ?string                 $createdByIp = null,
+        ?string                 $userAgent = null
+    ): SmartlinkToken {
+        $config ??= new TokenConfig();
+        $id = $this->ulidGenerator->generate($this->clock);;
+        $now = new \DateTimeImmutable();
+
+        $smartlinkData = new SmartlinkData(
+            id: $id,
+            action: $action,
+            payload: $payload,
+            expiresAt: $config->getExpiryDateTime(),
+            createdAt: $now,
+            oneTimeUse: $config->oneTimeUse,
+            createdByIp: $createdByIp,
+            userAgent: $userAgent
+        );
+
+        $token = new SmartlinkToken($id);
+        $this->tokens[$id] = $smartlinkData;
+
+        return $token;
+    }
+
+    public function validate(SmartlinkToken $token): ?SmartlinkData
+    {
+        if (!isset($this->tokens[$token->value])) {
+            return null;
+        }
+
+        $data = $this->tokens[$token->value];
+
+        if (!$data->isValid()) {
+            return null;
+        }
+
+        return $data;
+    }
+
+    public function markAsUsed(SmartlinkToken $token): void
+    {
+        if (isset($this->tokens[$token->value])) {
+            $data = $this->tokens[$token->value];
+            $this->tokens[$token->value] = $data->withUsed(new \DateTimeImmutable());
+        }
+    }
+
+    public function revoke(SmartlinkToken $token): void
+    {
+        unset($this->tokens[$token->value]);
+    }
+
+    public function exists(SmartlinkToken $token): bool
+    {
+        return isset($this->tokens[$token->value]) &&
+            $this->tokens[$token->value]->isValid();
+    }
+
+    public function getActiveTokens(int $limit = 100): array
+    {
+        return array_slice(
+            array_filter($this->tokens, fn($data) => $data->isValid()),
+            0,
+            $limit
+        );
+    }
+
+    public function cleanupExpired(): int
+    {
+        $count = 0;
+        foreach ($this->tokens as $id => $data) {
+            if ($data->isExpired()) {
+                unset($this->tokens[$id]);
+                $count++;
+            }
+        }
+        return $count;
+    }
+}
diff --git a/src/Framework/Smartlinks/Services/SmartlinkService.php b/src/Framework/Smartlinks/Services/SmartlinkService.php
new file mode 100644
index 00000000..62c52a77
--- /dev/null
+++ b/src/Framework/Smartlinks/Services/SmartlinkService.php
@@ -0,0 +1,52 @@
+<?php
+
+namespace App\Framework\Smartlinks\Services;
+
+use App\Framework\Smartlinks\SmartlinkData;
+use App\Framework\Smartlinks\SmartLinkToken;
+use App\Framework\Smartlinks\TokenAction;
+use App\Framework\Smartlinks\TokenConfig;
+
+interface SmartlinkService
+{
+    /**
+     * Generate a new smartlink token
+     */
+    public function generate(
+        TokenAction $action,
+        array $payload,
+        ?TokenConfig $config = null,
+        ?string $createdByIp = null,
+        ?string $userAgent = null
+    ): SmartlinkToken;
+
+    /**
+     * Validate and retrieve smartlink data
+     */
+    public function validate(SmartlinkToken $token): ?SmartlinkData;
+
+    /**
+     * Mark a token as used (for one-time use tokens)
+     */
+    public function markAsUsed(SmartlinkToken $token): void;
+
+    /**
+     * Revoke/invalidate a token
+     */
+    public function revoke(SmartlinkToken $token): void;
+
+    /**
+     * Check if a token exists and is valid
+     */
+    public function exists(SmartlinkToken $token): bool;
+
+    /**
+     * Get all active tokens for debugging/admin purposes
+     */
+    public function getActiveTokens(int $limit = 100): array;
+
+    /**
+     * Clean up expired tokens
+     */
+    public function cleanupExpired(): int;
+}
diff --git a/src/Framework/Smartlinks/SmartLinkToken.php b/src/Framework/Smartlinks/SmartLinkToken.php
new file mode 100644
index 00000000..ce212036
--- /dev/null
+++ b/src/Framework/Smartlinks/SmartLinkToken.php
@@ -0,0 +1,28 @@
+<?php
+
+namespace App\Framework\Smartlinks;
+
+final readonly class SmartLinkToken
+{
+    public function __construct(
+        public string $value
+    ) {
+        if (empty($value)) {
+            throw new \InvalidArgumentException('Token value cannot be empty');
+        }
+
+        if (strlen($value) < 16) {
+            throw new \InvalidArgumentException('Token must be at least 16 characters long');
+        }
+    }
+
+    public function equals(SmartLinkToken $other): bool
+    {
+        return hash_equals($this->value, $other->value);
+    }
+
+    public function __toString(): string
+    {
+        return $this->value;
+    }
+}
diff --git a/src/Framework/Smartlinks/SmartlinkData.php b/src/Framework/Smartlinks/SmartlinkData.php
new file mode 100644
index 00000000..5d9d1626
--- /dev/null
+++ b/src/Framework/Smartlinks/SmartlinkData.php
@@ -0,0 +1,56 @@
+<?php
+
+namespace App\Framework\Smartlinks;
+
+use DateTimeImmutable;
+
+final readonly class SmartlinkData
+{
+    public function __construct(
+        public string             $id,
+        public TokenAction        $action,
+        public array              $payload,
+        public DateTimeImmutable  $expiresAt,
+        public DateTimeImmutable  $createdAt,
+        public bool               $oneTimeUse = false,
+        public ?string            $createdByIp = null,
+        public ?string            $userAgent = null,
+        public bool $isUsed = false,
+        public ?DateTimeImmutable $usedAt = null
+    ) {}
+
+    public function isExpired(): bool
+    {
+        return $this->expiresAt <= new DateTimeImmutable();
+    }
+
+    public function isValid(): bool
+    {
+        return !$this->isExpired() && (!$this->oneTimeUse || !$this->isUsed);
+    }
+
+    public function getRemainingTime(): \DateInterval
+    {
+        $now = new DateTimeImmutable();
+        if ($this->isExpired()) {
+            return new \DateInterval('P0D');
+        }
+        return $now->diff($this->expiresAt);
+    }
+
+    public function withUsed(DateTimeImmutable $usedAt): self
+    {
+        return new self(
+            id: $this->id,
+            action: $this->action,
+            payload: $this->payload,
+            expiresAt: $this->expiresAt,
+            createdAt: $this->createdAt,
+            oneTimeUse: $this->oneTimeUse,
+            createdByIp: $this->createdByIp,
+            userAgent: $this->userAgent,
+            isUsed: true,
+            usedAt: $usedAt
+        );
+    }
+}
diff --git a/src/Framework/Smartlinks/SmartlinkInitializer.php b/src/Framework/Smartlinks/SmartlinkInitializer.php
new file mode 100644
index 00000000..8290a06c
--- /dev/null
+++ b/src/Framework/Smartlinks/SmartlinkInitializer.php
@@ -0,0 +1,34 @@
+<?php
+
+namespace App\Framework\Smartlinks;
+
+use App\Framework\DI\Container;
+use App\Framework\DI\Initializer;
+use App\Framework\Smartlinks\Actions\ActionRegistry;
+use App\Framework\Smartlinks\Actions\DefaultActionRegistry;
+use App\Framework\Smartlinks\Actions\EmailVerificationAction;
+use App\Framework\Smartlinks\Services\CacheSmartLinkService;
+use App\Framework\Smartlinks\Services\SmartlinkService;
+
+final readonly class SmartlinkInitializer
+{
+    public function __construct(
+        private Container $container
+    ){}
+
+    #[Initializer]
+    public function __invoke(): ActionRegistry
+    {
+        $registry = new DefaultActionRegistry;
+
+        $registry->register(new EmailVerificationAction());
+
+        return $registry;
+    }
+
+    #[Initializer]
+    public function init(): SmartlinkService
+    {
+        return $this->container->get(CacheSmartLinkService::class);
+    }
+}
diff --git a/src/Framework/Smartlinks/TokenAction.php b/src/Framework/Smartlinks/TokenAction.php
new file mode 100644
index 00000000..bcaba5fa
--- /dev/null
+++ b/src/Framework/Smartlinks/TokenAction.php
@@ -0,0 +1,28 @@
+<?php
+
+namespace App\Framework\Smartlinks;
+
+final readonly class TokenAction
+{
+    public function __construct(
+        public string $name
+    ) {
+        if (empty($name)) {
+            throw new \InvalidArgumentException('Action name cannot be empty');
+        }
+
+        if (!preg_match('/^[a-z_]+$/', $name)) {
+            throw new \InvalidArgumentException('Action name must contain only lowercase letters and underscores');
+        }
+    }
+
+    public function equals(TokenAction $other): bool
+    {
+        return $this->name === $other->name;
+    }
+
+    public function __toString(): string
+    {
+        return $this->name;
+    }
+}
diff --git a/src/Framework/Smartlinks/TokenConfig.php b/src/Framework/Smartlinks/TokenConfig.php
new file mode 100644
index 00000000..68fa89da
--- /dev/null
+++ b/src/Framework/Smartlinks/TokenConfig.php
@@ -0,0 +1,31 @@
+<?php
+
+namespace App\Framework\Smartlinks;
+
+use DateTimeImmutable;
+use InvalidArgumentException;
+
+final readonly class TokenConfig
+{
+    public function __construct(
+        public int $expiryHours = 24,
+        public bool $oneTimeUse = false,
+        public int $maxUses = 1,
+        public bool $requireSecureContext = false,
+        public array $allowedIpRanges = [],
+        public array $metadata = []
+    ) {
+        if ($expiryHours <= 0) {
+            throw new InvalidArgumentException('Expiry hours must be positive');
+        }
+
+        if ($maxUses <= 0) {
+            throw new InvalidArgumentException('Max uses must be positive');
+        }
+    }
+
+    public function getExpiryDateTime(): DateTimeImmutable
+    {
+        return new DateTimeImmutable("+{$this->expiryHours} hours");
+    }
+}
diff --git a/src/Framework/StaticSite/GenerateStaticSites.php b/src/Framework/StaticSite/GenerateStaticSites.php
new file mode 100644
index 00000000..70094221
--- /dev/null
+++ b/src/Framework/StaticSite/GenerateStaticSites.php
@@ -0,0 +1,30 @@
+<?php
+
+namespace App\Framework\StaticSite;
+
+use App\Framework\Console\ConsoleCommand;
+use App\Framework\Core\AppBootstrapper;
+use App\Framework\Core\PathProvider;
+use App\Framework\Http\Method;
+use App\Framework\HttpClient\ClientRequest;
+use App\Framework\HttpClient\CurlHttpClient;
+use App\Framework\Performance\PerformanceMeter;
+
+class GenerateStaticSites
+{
+    private string $outputDirectory;
+
+    public function __construct(
+        private readonly PathProvider $pathProvider
+    )
+    {
+        $this->outputDirectory = $this->pathProvider->resolvePath('/public') . '/static';
+    }
+
+    #[ConsoleCommand('static:generate', 'Generiert statische Seiten')]
+    public function generate(): void
+    {
+
+    }
+
+}
diff --git a/src/Framework/StaticSite/RouteCollector.php b/src/Framework/StaticSite/RouteCollector.php
new file mode 100644
index 00000000..eb599f08
--- /dev/null
+++ b/src/Framework/StaticSite/RouteCollector.php
@@ -0,0 +1,69 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\StaticSite;
+
+use App\Framework\Router\HttpRouter;
+use App\Framework\Router\Route;
+use App\Framework\Router\RouteCollection;
+
+class RouteCollector
+{
+    private HttpRouter $router;
+
+    public function __construct(HttpRouter $router)
+    {
+        $this->router = $router;
+    }
+
+    /**
+     * Sammelt alle Routen aus dem Router
+     *
+     * @return array Liste aller Routen-Pfade
+     */
+    public function collectRoutes(): array
+    {
+        $routes = [];
+        $routeCollection = $this->router->getRoutes();
+
+        if ($routeCollection instanceof RouteCollection) {
+            foreach ($routeCollection->getAll() as $route) {
+                if ($route instanceof Route) {
+                    $path = $route->path;
+                    // Nur GET-Routen für statische Seiten verwenden
+                    if (in_array('GET', $route->methods)) {
+                        $routes[] = $path;
+                    }
+                }
+            }
+        }
+
+        return $routes;
+    }
+
+    /**
+     * Filtert die Routen nach bestimmten Kriterien
+     *
+     * @param array $routes Liste der Routen
+     * @param array $exclude Pfade, die ausgeschlossen werden sollen
+     * @return array Gefilterte Routen
+     */
+    public function filterRoutes(array $routes, array $exclude = []): array
+    {
+        return array_filter($routes, function ($route) use ($exclude) {
+            // Prüfe, ob Route ausgeschlossen werden soll
+            foreach ($exclude as $pattern) {
+                if (preg_match($pattern, $route)) {
+                    return false;
+                }
+            }
+
+            // Schließe Routen mit Platzhaltern aus (z.B. /users/{id})
+            if (strpos($route, '{') !== false && strpos($route, '}') !== false) {
+                return false;
+            }
+
+            return true;
+        });
+    }
+}
diff --git a/src/Framework/StaticSite/StaticPageCollector.php b/src/Framework/StaticSite/StaticPageCollector.php
new file mode 100644
index 00000000..f0d86882
--- /dev/null
+++ b/src/Framework/StaticSite/StaticPageCollector.php
@@ -0,0 +1,106 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\StaticSite;
+
+use App\Framework\Attributes\StaticPage;
+use App\Framework\Router\HttpRouter;
+use App\Framework\Router\Route;
+use App\Framework\Router\RouteCollection;
+
+class StaticPageCollector
+{
+    private HttpRouter $router;
+
+    public function __construct(HttpRouter $router)
+    {
+        $this->router = $router;
+    }
+
+    /**
+     * Sammelt alle Routen mit dem StaticPage-Attribut
+     *
+     * @return array Liste aller statischen Seitenrouten
+     */
+    public function collectStaticPages(): array
+    {
+        $staticPages = [];
+        $routeCollection = $this->router->getRoutes();
+
+        if ($routeCollection instanceof RouteCollection) {
+            foreach ($routeCollection->getAll() as $route) {
+                if ($this->hasStaticPageAttribute($route->controller, $route->action)) {
+                    $staticPages[] = $route->path;
+                }
+            }
+        }
+
+        return $staticPages;
+    }
+
+    /**
+     * Sammelt alle GET-Routen unabhängig vom StaticPage-Attribut
+     *
+     * @return array Liste aller GET-Routen
+     */
+    public function collectAllGetRoutes(): array
+    {
+        $routes = [];
+        $routeCollection = $this->router->getRoutes();
+
+        if ($routeCollection instanceof RouteCollection) {
+            foreach ($routeCollection->getAll() as $route) {
+                if (in_array('GET', $route->methods)) {
+                    $routes[] = $route->path;
+                }
+            }
+        }
+
+        return $routes;
+    }
+
+    /**
+     * Prüft, ob die Controller-Methode das StaticPage-Attribut hat
+     */
+    private function hasStaticPageAttribute(string $controllerClass, string $methodName): bool
+    {
+        if (!class_exists($controllerClass) || !method_exists($controllerClass, $methodName)) {
+            return false;
+        }
+
+        try {
+            $reflectionMethod = new \ReflectionMethod($controllerClass, $methodName);
+            $attributes = $reflectionMethod->getAttributes(StaticPage::class);
+
+            return count($attributes) > 0;
+        } catch (\ReflectionException $e) {
+            return false;
+        }
+    }
+
+    /**
+     * Filtert die Routen nach bestimmten Kriterien
+     *
+     * @param array $routes Liste der Routen
+     * @param array $exclude Pfade, die ausgeschlossen werden sollen
+     * @return array Gefilterte Routen
+     */
+    public function filterRoutes(array $routes, array $exclude = []): array
+    {
+        return array_filter($routes, function ($route) use ($exclude) {
+            // Prüfe, ob Route ausgeschlossen werden soll
+            foreach ($exclude as $pattern) {
+                if (preg_match($pattern, $route)) {
+                    return false;
+                }
+            }
+
+            // Schließe Routen mit Platzhaltern aus (z.B. /users/{id})
+            if (strpos($route, '{') !== false && strpos($route, '}') !== false) {
+                return false;
+            }
+
+            return true;
+        });
+    }
+}
diff --git a/src/Framework/StaticSite/StaticSiteGenerator.php b/src/Framework/StaticSite/StaticSiteGenerator.php
new file mode 100644
index 00000000..8f9978da
--- /dev/null
+++ b/src/Framework/StaticSite/StaticSiteGenerator.php
@@ -0,0 +1,107 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\StaticSite;
+
+use App\Framework\Core\Application;
+use App\Framework\Http\Method;
+use App\Framework\Http\HttpRequest;
+use App\Framework\Http\Request;
+use App\Framework\Http\Response;
+
+class StaticSiteGenerator
+{
+    private Application $app;
+    private string $outputDir;
+    private array $routesToGenerate;
+
+    public function __construct(Application $app, array $routesToGenerate = [], ?string $outputDir = null)
+    {
+        $this->app = $app;
+        $this->routesToGenerate = $routesToGenerate;
+        $this->outputDir = $outputDir ?? dirname(__DIR__, 2) . '/public/static';
+    }
+
+    public function generate(): void
+    {
+        $this->prepareOutputDirectory();
+
+        foreach ($this->routesToGenerate as $route) {
+            $this->generateRoute($route);
+        }
+    }
+
+    private function prepareOutputDirectory(): void
+    {
+        if (!file_exists($this->outputDir)) {
+            mkdir($this->outputDir, 0755, true);
+        }
+    }
+
+    private function generateRoute(string $route): void
+    {
+        // Erstelle eine simulierte Anfrage
+        $request = new HttpRequest(Method::GET, $route, [], [], []);
+
+        try {
+            // Führe die Anfrage aus und erhalte die Antwort
+            $response = $this->app->handleRequest($request);
+
+            // Generiere den Pfad für die Datei
+            $filePath = $this->getFilePathForRoute($route);
+
+            // Stelle sicher, dass das Verzeichnis existiert
+            $directory = dirname($filePath);
+            if (!file_exists($directory)) {
+                mkdir($directory, 0755, true);
+            }
+
+            // Schreibe den Inhalt in die Datei
+            file_put_contents($filePath, $response->getBody());
+
+            echo "Statische Seite generiert: {$route} -> {$filePath}\n";
+        } catch (\Exception $e) {
+            echo "Fehler beim Generieren von {$route}: {$e->getMessage()}\n";
+        }
+    }
+
+    private function getFilePathForRoute(string $route): string
+    {
+        // Bereinige Route
+        $route = trim($route, '/');
+
+        // Bestimme den Dateinamen
+        if (empty($route)) {
+            $filePath = $this->outputDir . '/index.html';
+        } else {
+            // Für /about, /contact, etc.
+            if (strpos($route, '.') === false) {
+                // Keine Dateiendung vorhanden, erstelle Verzeichnis mit index.html
+                $filePath = $this->outputDir . '/' . $route . '/index.html';
+            } else {
+                // Dateiendung vorhanden (z.B. .json, .xml)
+                $filePath = $this->outputDir . '/' . $route;
+            }
+        }
+
+        return $filePath;
+    }
+
+    public function setRoutesToGenerate(array $routes): self
+    {
+        $this->routesToGenerate = $routes;
+        return $this;
+    }
+
+    public function addRoute(string $route): self
+    {
+        $this->routesToGenerate[] = $route;
+        return $this;
+    }
+
+    public function setOutputDirectory(string $directory): self
+    {
+        $this->outputDir = $directory;
+        return $this;
+    }
+}
diff --git a/src/Framework/StaticSite/StaticSiteMapper.php b/src/Framework/StaticSite/StaticSiteMapper.php
new file mode 100644
index 00000000..5334f419
--- /dev/null
+++ b/src/Framework/StaticSite/StaticSiteMapper.php
@@ -0,0 +1,26 @@
+<?php
+
+namespace App\Framework\StaticSite;
+
+use App\Framework\Attributes\Route;
+use App\Framework\Attributes\StaticPage;
+use App\Framework\Core\AttributeMapper;
+
+final readonly class StaticSiteMapper implements AttributeMapper
+{
+
+    public function getAttributeClass(): string
+    {
+        return StaticPage::class;
+    }
+
+    public function map(object $reflectionTarget, object $attributeInstance): ?array
+    {
+        $route = $reflectionTarget->getAttributes(Route::class);
+
+
+        return [
+            'route' => $route[0]->newInstance()->path,
+        ];
+    }
+}
diff --git a/src/Framework/SyntaxHighlighter/FileHighlighter.php b/src/Framework/SyntaxHighlighter/FileHighlighter.php
new file mode 100644
index 00000000..b7757cf2
--- /dev/null
+++ b/src/Framework/SyntaxHighlighter/FileHighlighter.php
@@ -0,0 +1,30 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\SyntaxHighlighter;
+
+use SplFileObject;
+
+final readonly class FileHighlighter
+{
+    public function __invoke(string $filename, int $startLine, int $range):string
+    {
+        $file = new SplFileObject($filename);
+
+        // Zu Zeile 9 springen (Index basiert auf 0, daher Zeile 10 = 9)
+        $file->seek($startLine);
+
+        $lines = [];
+        for ($i = 0; $i < $range && !$file->eof(); $i++) {
+            $lines[] = $file->current();
+            $file->next();
+        }
+
+        $code = implode('', $lines);
+
+        $highlighter = new SyntaxHighlighter();
+
+        #echo "<style>$css</style>";
+        return $highlighter->highlightFileSegment($code, $startLine);
+    }
+}
diff --git a/src/Framework/SyntaxHighlighter/Formatters/ConsoleFormatter.php b/src/Framework/SyntaxHighlighter/Formatters/ConsoleFormatter.php
new file mode 100644
index 00000000..a4f1ed4a
--- /dev/null
+++ b/src/Framework/SyntaxHighlighter/Formatters/ConsoleFormatter.php
@@ -0,0 +1,125 @@
+<?php
+
+namespace App\Framework\SyntaxHighlighter\Formatters;
+
+use App\Framework\SyntaxHighlighter\Token;
+use App\Framework\SyntaxHighlighter\TokenType;
+
+class ConsoleFormatter implements FormatterInterface {
+    private const string RESET = "\033[0m";
+    private bool $useColors;
+
+    public function __construct(?bool $useColors = null) {
+        $this->useColors = $useColors ?? $this->isColorSupported();
+    }
+
+    public function format(array $tokens, array $options = []): string {
+        $showLineNumbers = $options['lineNumbers'] ?? false;
+        $startLine = $options['startLine'] ?? 1;
+        $width = $options['width'] ?? 80;
+
+        if (!$this->useColors) {
+            return $this->formatPlainText($tokens, $showLineNumbers, $startLine);
+        }
+
+        $lines = $this->groupTokensByLines($tokens);
+        $output = [];
+        $lineNumberWidth = strlen((string) (count($lines) + $startLine - 1));
+
+        foreach ($lines as $lineNumber => $lineTokens) {
+            $actualLineNumber = $lineNumber + $startLine - 1;
+            $lineContent = $this->formatLine($lineTokens);
+
+            if ($showLineNumbers) {
+                $lineNumberStr = str_pad($actualLineNumber, $lineNumberWidth, ' ', STR_PAD_LEFT);
+                $output[] = "\033[90m{$lineNumberStr}\033[0m │ {$lineContent}";
+            } else {
+                $output[] = $lineContent;
+            }
+        }
+
+        return implode("\n", $output);
+    }
+
+    /*private function isColorSupported(): bool {
+        return DIRECTORY_SEPARATOR === '/' &&
+               function_exists('posix_isatty') &&
+               posix_isatty(STDOUT);
+    }*/
+
+    private function groupTokensByLines(array $tokens): array {
+        $lines = [];
+        $currentLine = 1;
+
+        foreach ($tokens as $token) {
+            if (!isset($lines[$currentLine])) {
+                $lines[$currentLine] = [];
+            }
+
+            if (str_contains($token->value, "\n")) {
+                $parts = explode("\n", $token->value);
+                for ($i = 0; $i < count($parts); $i++) {
+                    if ($i > 0) {
+                        $currentLine++;
+                        if (!isset($lines[$currentLine])) {
+                            $lines[$currentLine] = [];
+                        }
+                    }
+                    if ($parts[$i] !== '') {
+                        $lines[$currentLine][] = new Token(
+                            $token->type,
+                            $parts[$i],
+                            $currentLine,
+                            $token->column
+                        );
+                    }
+                }
+            } else {
+                $lines[$currentLine][] = $token;
+            }
+        }
+
+        return $lines;
+    }
+
+    private function formatLine(array $tokens): string {
+        $content = '';
+
+        foreach ($tokens as $token) {
+            $content .= $this->formatToken($token);
+        }
+
+        return $content . self::RESET;
+    }
+
+    private function formatToken(Token $token): string {
+        if ($token->type === TokenType::WHITESPACE) {
+            return $token->value;
+        }
+
+        $color = $token->type->getConsoleColor();
+        return $color . $token->value . self::RESET;
+    }
+
+    private function formatPlainText(array $tokens, bool $showLineNumbers, int $startLine): string {
+        $content = '';
+        $lineNumber = $startLine;
+        $atLineStart = true;
+
+        foreach ($tokens as $token) {
+            if ($atLineStart && $showLineNumbers) {
+                $content .= sprintf('%3d: ', $lineNumber);
+                $atLineStart = false;
+            }
+
+            $content .= $token->value;
+
+            if (str_contains($token->value, "\n")) {
+                $lineNumber += substr_count($token->value, "\n");
+                $atLineStart = true;
+            }
+        }
+
+        return $content;
+    }
+}
diff --git a/src/Framework/SyntaxHighlighter/Formatters/FormatterInterface.php b/src/Framework/SyntaxHighlighter/Formatters/FormatterInterface.php
new file mode 100644
index 00000000..45bc4729
--- /dev/null
+++ b/src/Framework/SyntaxHighlighter/Formatters/FormatterInterface.php
@@ -0,0 +1,7 @@
+<?php
+
+namespace App\Framework\SyntaxHighlighter\Formatters;
+
+interface FormatterInterface {
+    public function format(array $tokens, array $options = []): string;
+}
diff --git a/src/Framework/SyntaxHighlighter/Formatters/HtmlFormatter.php b/src/Framework/SyntaxHighlighter/Formatters/HtmlFormatter.php
new file mode 100644
index 00000000..cc80ba75
--- /dev/null
+++ b/src/Framework/SyntaxHighlighter/Formatters/HtmlFormatter.php
@@ -0,0 +1,326 @@
+<?php
+
+namespace App\Framework\SyntaxHighlighter\Formatters;
+
+use App\Framework\SyntaxHighlighter\Token;
+use App\Framework\SyntaxHighlighter\TokenType;
+
+class HtmlFormatter implements FormatterInterface {
+    private array $theme = [
+        'keyword' => '#0000FF',
+        'variable' => '#800080',
+        'string' => '#008000',
+        'identifier' => '#000000',
+        'number' => '#FF0000',
+        'comment' => '#808080',
+        'doc-comment' => '#008080',
+        'php-tag' => '#000080',
+        'operator' => '#000080',
+        'background' => '#F8F8F8',
+        'border' => '#DDDDDD',
+        'line-number' => '#999999',
+    ];
+
+    private static bool $cssOutputted = false;
+
+    public function setTheme(array $theme): self {
+        $this->theme = array_merge($this->theme, $theme);
+        return $this;
+    }
+
+    public function format(array $tokens, array $options = []): string {
+        $showLineNumbers = $options['lineNumbers'] ?? true;
+        $startLine = $options['startLine'] ?? 1;
+        $lineOffset = $options['lineOffset'] ?? 0; // Neuer Offset Parameter
+        $highlightLines = $options['highlightLines'] ?? [];
+        $cssClasses = $options['cssClasses'] ?? true;
+        $includeCss = $options['includeCss'] ?? true;
+        $language = $options['language'] ?? 'php';
+
+        $lines = $this->groupTokensByLines($tokens);
+        $output = [];
+
+        foreach ($lines as $lineNumber => $lineTokens) {
+            // Berücksichtigung von startLine und lineOffset
+            $actualLineNumber = $lineNumber + $startLine - 1 + $lineOffset;
+            $isHighlighted = in_array($actualLineNumber, $highlightLines);
+
+            $lineContent = $this->formatLine($lineTokens, $cssClasses);
+            $output[] = rtrim($this->wrapLine(
+                $lineContent,
+                $actualLineNumber,
+                $showLineNumbers,
+                $isHighlighted
+            ));
+        }
+
+        $codeOutput = $this->wrapOutput(implode("\n", $output), $options);
+
+        // CSS automatisch einbinden (nur einmal pro Request)
+        if ($includeCss && !self::$cssOutputted) {
+            $css = $this->generateCss($options);
+            self::$cssOutputted = true;
+            return $css . "\n" . $codeOutput;
+        }
+
+        return $codeOutput;
+    }
+
+    private function generateCss(array $options = []): string {
+        $tabSize = $options['tabSize'] ?? 4;
+        $fontSize = $options['fontSize'] ?? '14px';
+        $lineHeight = $options['lineHeight'] ?? '1.5';
+
+        return sprintf(
+            '<style>%s</style>',
+            $this->getCssRules($tabSize, $fontSize, $lineHeight)
+        );
+    }
+
+    private function getCssRules(int $tabSize, string $fontSize, string $lineHeight): string {
+        return <<<CSS
+.syntax-highlighter {
+    border-radius: 6px;
+    overflow-x: auto;
+    margin: 1em auto;
+    position: relative;
+    background-color: {$this->theme['background']};
+    border: 1px solid {$this->theme['border']};
+    max-width: fit-content;
+    cursor: text;
+}
+
+.syntax-highlighter code {
+    font-family: 'Consolas', 'Monaco', 'Courier New', monospace;
+    font-size: {$fontSize};
+    line-height: {$lineHeight};
+    padding: 16px;
+    display: inline-flex;
+    flex-direction: column;
+    white-space: pre;
+    tab-size: {$tabSize};
+    color: inherit;
+    background: none;
+    margin: 0;
+}
+
+.syntax-highlighter .line {
+    display: inline-flex;
+    min-height: {$lineHeight}em;
+    width: 100%;
+
+    &:hover .line-number {
+    font-weight: bold;
+    }
+
+    &:hover {
+    background-color: rgba(255, 255, 0, 0.1);
+    }
+}
+
+.syntax-highlighter .line.highlighted {
+    background-color: rgba(255, 255, 0, 0.1);
+}
+
+.syntax-highlighter .line-number {
+    padding-right: 16px;
+    min-width: 40px;
+    text-align: right;
+    border-right: 1px solid {$this->theme['border']};
+    margin-right: 16px;
+    user-select: none;
+    color: {$this->theme['line-number']};
+}
+
+.syntax-highlighter .code {
+    flex: 1;
+    padding-left: 8px;
+}
+
+/* Token Styles */
+.syntax-highlighter .token-keyword {
+    color: {$this->theme['keyword']};
+    font-weight: bold;
+}
+
+.syntax-highlighter .token-variable {
+    color: {$this->theme['variable']};
+}
+
+.syntax-highlighter .token-string {
+    color: {$this->theme['string']};
+}
+
+.syntax-highlighter .token-comment {
+    color: {$this->theme['comment']};
+    font-style: italic;
+}
+
+.syntax-highlighter .token-doc-comment {
+    color: {$this->theme['doc-comment']};
+    font-style: italic;
+}
+
+.syntax-highlighter .token-number {
+    color: {$this->theme['number']};
+}
+
+.syntax-highlighter .token-php-tag {
+    color: {$this->theme['php-tag']};
+    font-weight: bold;
+}
+
+.syntax-highlighter .token-operator {
+    color: {$this->theme['operator']};
+}
+
+.syntax-highlighter .token-identifier {
+    color: {$this->theme['identifier']};
+}
+
+/* Copy Button */
+.syntax-highlighter .copy-btn {
+    position: absolute;
+    top: 8px;
+    right: 8px;
+    background: rgba(0, 0, 0, 0.8);
+    color: white;
+    border: none;
+    padding: 4px 8px;
+    border-radius: 4px;
+    font-size: 12px;
+    cursor: pointer;
+    opacity: 0;
+    transition: opacity 0.2s;
+}
+
+.syntax-highlighter:hover .copy-btn {
+    opacity: 1;
+}
+
+.syntax-highlighter .copy-btn:hover {
+    background: rgba(0, 0, 0, 0.9);
+}
+CSS;
+    }
+
+    public static function resetCssOutput(): void {
+        self::$cssOutputted = false;
+    }
+
+    public function getCss(array $options = []): string {
+        return $this->generateCss($options);
+    }
+
+    private function groupTokensByLines(array $tokens): array {
+        $lines = [];
+        $currentLine = 1;
+
+        foreach ($tokens as $token) {
+            if (!isset($lines[$currentLine])) {
+                $lines[$currentLine] = [];
+            }
+
+            // Spezielle Behandlung für reine Newline-Token
+            if ($token->value === "\n") {
+                $currentLine++;
+                continue;
+            }
+
+            if (str_contains($token->value, "\n")) {
+                $parts = explode("\n", $token->value);
+
+                // Ersten Teil zur aktuellen Zeile hinzufügen
+                if ($parts[0] !== '') {
+                    $lines[$currentLine][] = new Token(
+                        $token->type,
+                        $parts[0],
+                        $currentLine,
+                        $token->column
+                    );
+                }
+
+                // Für jeden Newline eine neue Zeile erstellen
+                for ($i = 1; $i < count($parts); $i++) {
+                    $currentLine++;
+                    if (!isset($lines[$currentLine])) {
+                        $lines[$currentLine] = [];
+                    }
+
+                    // Nur nicht-leere Teile hinzufügen
+                    if ($parts[$i] !== '') {
+                        $lines[$currentLine][] = new Token(
+                            $token->type,
+                            $parts[$i],
+                            $currentLine,
+                            $token->column
+                        );
+                    }
+                }
+            } else {
+                $lines[$currentLine][] = $token;
+            }
+        }
+
+        return $lines;
+    }
+
+    private function formatLine(array $tokens, bool $useCssClasses): string {
+        $content = '';
+
+        foreach ($tokens as $token) {
+            $content .= $this->formatToken($token, $useCssClasses);
+        }
+
+        return $content;
+    }
+
+    private function formatToken(Token $token, bool $useCssClasses): string {
+        $escapedValue = htmlspecialchars($token->value);
+
+        if ($token->type === TokenType::WHITESPACE) {
+            return $escapedValue;
+        }
+
+        if ($useCssClasses) {
+            return sprintf('<span class="%s">%s</span>',
+                $token->type->getCssClass(), $escapedValue);
+        } else {
+            $color = $this->theme[$token->type->value] ?? $this->theme['identifier'];
+            return sprintf('<span style="color: %s;">%s</span>',
+                $color, $escapedValue);
+        }
+    }
+
+    private function wrapLine(string $content, int $lineNumber, bool $showLineNumbers, bool $isHighlighted): string {
+        $lineClass = $isHighlighted ? 'line highlighted' : 'line';
+
+        if ($showLineNumbers) {
+            $lineNumberSpan = sprintf(
+                '<span class="line-number">%d</span>',
+                $lineNumber
+            );
+            return sprintf('<div class="%s">%s<span class="code">%s</span></div>',
+                $lineClass, $lineNumberSpan, $content);
+        }
+
+        return sprintf('<div class="%s">%s</div>', $lineClass, $content);
+    }
+
+    private function wrapOutput(string $content, array $options): string {
+        $containerClass = $options['containerClass'] ?? 'syntax-highlighter';
+        $language = $options['language'] ?? 'php';
+        $copyButton = $options['copyButton'] ?? false;
+
+        $copyButtonHtml = $copyButton ?
+            '<button class="copy-btn" onclick="navigator.clipboard.writeText(this.nextElementSibling.querySelector(\'code\').textContent)">Copy</button>' : '';
+
+        return sprintf(
+            '<pre class="%s">%s<code class="language-%s">%s</code></pre>',
+            $containerClass,
+            $copyButtonHtml,
+            $language,
+            $content
+        );
+    }
+}
diff --git a/src/Framework/SyntaxHighlighter/SyntaxHighlighter.php b/src/Framework/SyntaxHighlighter/SyntaxHighlighter.php
new file mode 100644
index 00000000..d2192cf2
--- /dev/null
+++ b/src/Framework/SyntaxHighlighter/SyntaxHighlighter.php
@@ -0,0 +1,94 @@
+<?php
+
+namespace App\Framework\SyntaxHighlighter;
+
+use App\Framework\SyntaxHighlighter\Formatters\FormatterInterface;
+use App\Framework\SyntaxHighlighter\Formatters\HtmlFormatter;
+use App\Framework\SyntaxHighlighter\Formatters\ConsoleFormatter;
+
+final readonly class SyntaxHighlighter {
+    public Tokenizer $tokenizer;
+    private array $formatters;
+
+    public function __construct(
+        public TokenMapper $tokenMapper = new TokenMapper(),
+        ?Tokenizer $tokenizer = null
+    ) {
+        $this->tokenizer = $tokenizer ?? new Tokenizer($this->tokenMapper);
+        $this->registerDefaultFormatters();
+    }
+
+    private function registerDefaultFormatters(): void {
+        $formatters['html'] = new HtmlFormatter();
+        #$this->formatters['console'] = new ConsoleFormatter();
+
+        $this->formatters = $formatters;
+    }
+
+    public function highlight(string $code, string $format = 'html', array $options = []): string {
+        if (!isset($this->formatters[$format])) {
+            throw new \InvalidArgumentException("Unbekannter Formatter: {$format}");
+        }
+
+        $tokens = $this->tokenizer->tokenize($code);
+        return $this->formatters[$format]->format($tokens, $options);
+    }
+
+    public function getFormatter(string $name): FormatterInterface {
+        if (!isset($this->formatters[$name])) {
+            throw new \InvalidArgumentException("Unbekannter Formatter: {$name}");
+        }
+
+        return $this->formatters[$name];
+    }
+
+    public function tokenize(string $code): array {
+        return $this->tokenizer->tokenize($code);
+    }
+
+    public function addTokenMapping(int $phpToken, TokenType $tokenType): self {
+        $this->tokenMapper->addMapping($phpToken, $tokenType);
+        return $this;
+    }
+
+    public function setCustomTokenMappings(array $mappings): self {
+        $this->tokenMapper->mergeMappings($mappings);
+        return $this;
+    }
+
+    public function highlightWithCss(string $code, array $options = []): string {
+        $options['includeCss'] = true;
+        return $this->highlight($code, 'html', $options);
+    }
+
+    public function highlightWithoutCss(string $code, array $options = []): string {
+        $options['includeCss'] = false;
+        return $this->highlight($code, 'html', $options);
+    }
+
+    public function getCss(array $options = []): string {
+        $formatter = $this->getFormatter('html');
+        if (method_exists($formatter, 'getCss')) {
+            return $formatter->getCss($options);
+        }
+        return '';
+    }
+
+    public function resetCssOutput(): self {
+        if (method_exists($this->getFormatter('html'), 'resetCssOutput')) {
+            $this->getFormatter('html')::resetCssOutput();
+        }
+        return $this;
+    }
+
+    public function highlightWithOffset(string $code, int $lineOffset, array $options = []): string {
+        $options['lineOffset'] = $lineOffset;
+        return $this->highlight($code, 'html', $options);
+    }
+
+    public function highlightFileSegment(string $code, int $startLineInFile, array $options = []): string {
+        // startLineInFile ist die tatsächliche Zeilennummer in der Datei
+        $options['lineOffset'] = $startLineInFile - 1;
+        return $this->highlight($code, 'html', $options);
+    }
+}
diff --git a/src/Framework/SyntaxHighlighter/Token.php b/src/Framework/SyntaxHighlighter/Token.php
new file mode 100644
index 00000000..99584ba8
--- /dev/null
+++ b/src/Framework/SyntaxHighlighter/Token.php
@@ -0,0 +1,13 @@
+<?php
+
+namespace App\Framework\SyntaxHighlighter;
+
+final readonly class Token {
+    public function __construct(
+        public TokenType $type,
+        public string    $value,
+        public int       $line = 1,
+        public int       $column = 1
+    ) {}
+}
+
diff --git a/src/Framework/SyntaxHighlighter/TokenMapper.php b/src/Framework/SyntaxHighlighter/TokenMapper.php
new file mode 100644
index 00000000..c3fc1a07
--- /dev/null
+++ b/src/Framework/SyntaxHighlighter/TokenMapper.php
@@ -0,0 +1,132 @@
+<?php
+
+namespace App\Framework\SyntaxHighlighter;
+
+final class TokenMapper {
+    private array $mapping = [];
+
+    public function __construct() {
+        $this->initializeDefaultMapping();
+    }
+
+    private function initializeDefaultMapping(): void {
+        $this->mapping = [
+            // Schlüsselwörter
+            T_ABSTRACT => TokenType::KEYWORD,
+            T_ARRAY => TokenType::KEYWORD,
+            T_AS => TokenType::KEYWORD,
+            T_BREAK => TokenType::KEYWORD,
+            T_CASE => TokenType::KEYWORD,
+            T_CATCH => TokenType::KEYWORD,
+            T_CLASS => TokenType::KEYWORD,
+            T_CLONE => TokenType::KEYWORD,
+            T_CONST => TokenType::KEYWORD,
+            T_CONTINUE => TokenType::KEYWORD,
+            T_DEFAULT => TokenType::KEYWORD,
+            T_DO => TokenType::KEYWORD,
+            T_ECHO => TokenType::KEYWORD,
+            T_ELSE => TokenType::KEYWORD,
+            T_ELSEIF => TokenType::KEYWORD,
+            T_EMPTY => TokenType::KEYWORD,
+            T_EXTENDS => TokenType::KEYWORD,
+            T_FINAL => TokenType::KEYWORD,
+            T_FINALLY => TokenType::KEYWORD,
+            T_FOR => TokenType::KEYWORD,
+            T_FOREACH => TokenType::KEYWORD,
+            T_FUNCTION => TokenType::KEYWORD,
+            T_IF => TokenType::KEYWORD,
+            T_IMPLEMENTS => TokenType::KEYWORD,
+            T_INCLUDE => TokenType::KEYWORD,
+            T_INCLUDE_ONCE => TokenType::KEYWORD,
+            T_INSTANCEOF => TokenType::KEYWORD,
+            T_INTERFACE => TokenType::KEYWORD,
+            T_ISSET => TokenType::KEYWORD,
+            T_NAMESPACE => TokenType::KEYWORD,
+            T_NEW => TokenType::KEYWORD,
+            T_PRIVATE => TokenType::KEYWORD,
+            T_PROTECTED => TokenType::KEYWORD,
+            T_PUBLIC => TokenType::KEYWORD,
+            T_REQUIRE => TokenType::KEYWORD,
+            T_REQUIRE_ONCE => TokenType::KEYWORD,
+            T_RETURN => TokenType::KEYWORD,
+            T_STATIC => TokenType::KEYWORD,
+            T_SWITCH => TokenType::KEYWORD,
+            T_THROW => TokenType::KEYWORD,
+            T_TRY => TokenType::KEYWORD,
+            T_UNSET => TokenType::KEYWORD,
+            T_USE => TokenType::KEYWORD,
+            T_VAR => TokenType::KEYWORD,
+            T_WHILE => TokenType::KEYWORD,
+            T_YIELD => TokenType::KEYWORD,
+
+            // Variablen und Strings
+            T_VARIABLE => TokenType::VARIABLE,
+            T_CONSTANT_ENCAPSED_STRING => TokenType::STRING,
+            T_ENCAPSED_AND_WHITESPACE => TokenType::STRING,
+            T_STRING => TokenType::IDENTIFIER,
+
+            // Zahlen
+            T_LNUMBER => TokenType::NUMBER,
+            T_DNUMBER => TokenType::NUMBER,
+
+            // Kommentare
+            T_COMMENT => TokenType::COMMENT,
+            T_DOC_COMMENT => TokenType::DOC_COMMENT,
+
+            // PHP Tags
+            T_OPEN_TAG => TokenType::PHP_TAG,
+            T_OPEN_TAG_WITH_ECHO => TokenType::PHP_TAG,
+            T_CLOSE_TAG => TokenType::PHP_TAG,
+
+            // Operatoren
+            T_DOUBLE_ARROW => TokenType::OPERATOR,
+            T_OBJECT_OPERATOR => TokenType::OPERATOR,
+            T_PAAMAYIM_NEKUDOTAYIM => TokenType::OPERATOR,
+            T_BOOLEAN_AND => TokenType::OPERATOR,
+            T_BOOLEAN_OR => TokenType::OPERATOR,
+            T_IS_EQUAL => TokenType::OPERATOR,
+            T_IS_NOT_EQUAL => TokenType::OPERATOR,
+            T_IS_IDENTICAL => TokenType::OPERATOR,
+            T_IS_NOT_IDENTICAL => TokenType::OPERATOR,
+            T_IS_SMALLER_OR_EQUAL => TokenType::OPERATOR,
+            T_IS_GREATER_OR_EQUAL => TokenType::OPERATOR,
+            T_SPACESHIP => TokenType::OPERATOR,
+            T_COALESCE => TokenType::OPERATOR,
+
+            // Whitespace
+            T_WHITESPACE => TokenType::WHITESPACE,
+        ];
+    }
+
+    public function getTokenType(int $phpToken): TokenType {
+        return $this->mapping[$phpToken] ?? TokenType::DEFAULT;
+    }
+
+    public function addMapping(int $phpToken, TokenType $tokenType): self {
+        $this->mapping[$phpToken] = $tokenType;
+        return $this;
+    }
+
+    public function removeMapping(int $phpToken): self {
+        unset($this->mapping[$phpToken]);
+        return $this;
+    }
+
+    public function hasMapping(int $phpToken): bool {
+        return isset($this->mapping[$phpToken]);
+    }
+
+    public function getAllMappings(): array {
+        return $this->mapping;
+    }
+
+    public function setMappings(array $mappings): self {
+        $this->mapping = $mappings;
+        return $this;
+    }
+
+    public function mergeMappings(array $additionalMappings): self {
+        $this->mapping = array_merge($this->mapping, $additionalMappings);
+        return $this;
+    }
+}
diff --git a/src/Framework/SyntaxHighlighter/TokenType.php b/src/Framework/SyntaxHighlighter/TokenType.php
new file mode 100644
index 00000000..be332212
--- /dev/null
+++ b/src/Framework/SyntaxHighlighter/TokenType.php
@@ -0,0 +1,36 @@
+<?php
+
+namespace App\Framework\SyntaxHighlighter;
+
+enum TokenType: string {
+    case KEYWORD = 'keyword';
+    case VARIABLE = 'variable';
+    case STRING = 'string';
+    case IDENTIFIER = 'identifier';
+    case NUMBER = 'number';
+    case COMMENT = 'comment';
+    case DOC_COMMENT = 'doc-comment';
+    case PHP_TAG = 'php-tag';
+    case OPERATOR = 'operator';
+    case WHITESPACE = 'whitespace';
+    case DEFAULT = 'default';
+
+    public function getCssClass(): string {
+        return 'token-' . $this->value;
+    }
+
+    public function getConsoleColor(): string {
+        return match($this) {
+            self::KEYWORD => "\033[34m",      // Blau
+            self::VARIABLE => "\033[35m",     // Magenta
+            self::STRING => "\033[32m",       // Grün
+            self::IDENTIFIER => "\033[37m",   // Weiß
+            self::NUMBER => "\033[31m",       // Rot
+            self::COMMENT => "\033[90m",      // Grau
+            self::DOC_COMMENT => "\033[36m",  // Cyan
+            self::PHP_TAG => "\033[94m",      // Helles Blau
+            self::OPERATOR => "\033[33m",     // Gelb
+            default => "\033[0m",             // Reset
+        };
+    }
+}
diff --git a/src/Framework/SyntaxHighlighter/Tokenizer.php b/src/Framework/SyntaxHighlighter/Tokenizer.php
new file mode 100644
index 00000000..94884c51
--- /dev/null
+++ b/src/Framework/SyntaxHighlighter/Tokenizer.php
@@ -0,0 +1,48 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\SyntaxHighlighter;
+
+final readonly class Tokenizer {
+    public function __construct(
+        private TokenMapper $tokenMapper = new TokenMapper()
+    ) {}
+
+    public function tokenize(string $code): array {
+        $phpTokens = token_get_all($code);
+        $tokens = [];
+        $line = 1;
+        $column = 1;
+
+        foreach ($phpTokens as $phpToken) {
+            if (is_array($phpToken)) {
+                $tokenType = $this->tokenMapper->getTokenType($phpToken[0]);
+                $value = $phpToken[1];
+                $tokenLine = $phpToken[2] ?? $line;
+
+                $tokens[] = new Token($tokenType, $value, $tokenLine, $column);
+
+                // Zeilen- und Spaltenzählung aktualisieren
+                $newlines = substr_count($value, "\n");
+                if ($newlines > 0) {
+                    $line += $newlines;
+                    $column = strlen(substr($value, strrpos($value, "\n") + 1)) + 1;
+                } else {
+                    $column += strlen($value);
+                }
+            } else {
+                // Einzelne Zeichen
+                $tokens[] = new Token(TokenType::DEFAULT, $phpToken, $line, $column);
+
+                if ($phpToken === "\n") {
+                    $line++;
+                    $column = 1;
+                } else {
+                    $column++;
+                }
+            }
+        }
+
+        return $tokens;
+    }
+}
diff --git a/src/Framework/Ulid/StringConverter.php b/src/Framework/Ulid/StringConverter.php
new file mode 100644
index 00000000..06c8e7d7
--- /dev/null
+++ b/src/Framework/Ulid/StringConverter.php
@@ -0,0 +1,69 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Ulid;
+
+use InvalidArgumentException;
+
+/**
+ * A utility class for encoding and decoding Base32 strings using a custom alphabet.
+ */
+final readonly class StringConverter
+{
+    /**
+     * Encodes a binary string into a Base32 encoded string using a custom alphabet.
+     *
+     * @param string $binary The binary string to be encoded.
+     * @return string The Base32 encoded string.
+     */
+    public function encodeBase32(string $binary): string
+    {
+        $alphabet = '0123456789ABCDEFGHJKMNPQRSTVWXYZ';
+        $bits = '';
+        foreach (str_split($binary) as $byte) {
+            $bits .= str_pad(decbin(ord($byte)), 8, '0', STR_PAD_LEFT);
+        }
+
+        $ulid = '';
+        for ($i = 0; $i < 130; $i += 5) {
+            $chunk = substr($bits, $i, 5);
+            if (strlen($chunk) < 5) {
+                $chunk = str_pad($chunk, 5, '0', STR_PAD_RIGHT);
+            }
+            $ulid .= $alphabet[bindec($chunk)];
+        }
+        return $ulid;
+    }
+
+    /**
+     * Decodes a Base32-encoded string into its binary representation.
+     *
+     * @param string $base32 The Base32-encoded string to decode.
+     * @return string The binary representation of the decoded string.
+     * @throws InvalidArgumentException If the provided string contains invalid Base32 characters.
+     */
+    public function decodeBase32(string $base32): string
+    {
+        $alphabet = '0123456789ABCDEFGHJKMNPQRSTVWXYZ';
+        $bits = '';
+
+        // Jeden Base32-Charakter in 5 Bit umwandeln
+        for ($i = 0, $len = strlen($base32); $i < $len; $i++) {
+            $char = $base32[$i];
+            $index = strpos($alphabet, $char);
+            if ($index === false) {
+                throw new InvalidArgumentException("Zeichen '$char' ist kein gültiges Base32-Zeichen.");
+            }
+            $bits .= str_pad(decbin($index), 5, '0', STR_PAD_LEFT);
+        }
+
+        // Bits in Bytes umwandeln (immer 8 Bit zusammenfassen)
+        $binary = '';
+        for ($i = 0, $bitsLen = strlen($bits); $i + 8 <= $bitsLen; $i += 8) {
+            $byte = substr($bits, $i, 8);
+            $binary .= chr(bindec($byte));
+        }
+
+        return $binary;
+    }
+}
diff --git a/src/Framework/Ulid/Ulid.php b/src/Framework/Ulid/Ulid.php
new file mode 100644
index 00000000..8b5585e5
--- /dev/null
+++ b/src/Framework/Ulid/Ulid.php
@@ -0,0 +1,99 @@
+<?php
+
+namespace App\Framework\Ulid;
+
+use App\Framework\DateTime\Clock;
+use DateTimeImmutable;
+use InvalidArgumentException;
+use JsonSerializable;
+
+/**
+ * Objekt-Wrapper für ULIDs mit String-/JSON-API.
+ */
+final readonly class Ulid implements JsonSerializable
+{
+    private string $ulid;
+
+    private StringConverter $converter;
+
+    public function __construct(
+        private Clock $clock,
+        ?string $ulid = null,
+        bool $isBase32 = false,
+    ){
+        $gen       = new ULIDGenerator();
+        $validator = new ULIDValidator();
+        $this->converter = new StringConverter();
+
+        if ($ulid === null) {
+
+                $this->ulid = $gen->generate($this->clock);
+
+        } else {
+
+            if($isBase32)
+            {
+                $this->ulid = $this->converter->encodeBase32($ulid);
+                return;
+            }
+
+
+            if (! $validator->isValid($ulid)) {
+                throw new InvalidArgumentException("Ungültige ULID: $ulid");
+            }
+            $this->ulid = $ulid;
+        }
+    }
+
+    public static function fromBase32(Clock $clock, string $ulid): self
+    {
+        return new self($clock, $ulid, true);
+    }
+
+    public function toBinary(): string
+    {
+        return $this->converter->decodeBase32($this->ulid);
+    }
+
+    public function __toString(): string
+    {
+        return $this->ulid;
+    }
+
+    public function jsonSerialize(): string
+    {
+        return $this->ulid;
+    }
+
+    public function getTimestampMs(): int
+    {
+        $parser = new ULIDParser(new ULIDValidator());
+        return $parser->getTimestampMs($this->ulid);
+    }
+
+    public function getDateTime(): DateTimeImmutable
+    {
+        $parser = new ULIDParser(new ULIDValidator());
+        return $parser->getDateTime($this->ulid, $this->clock);
+    }
+
+    public static function isValid(string $ulid): bool
+    {
+        return new ULIDValidator()->isValid($ulid);
+    }
+
+    public static function fromString(Clock $clock, string $ulid): self
+    {
+        return new self($clock, $ulid);
+    }
+
+    public function __debugInfo(): ?array
+    {
+        return [
+            'ulid' => $this->ulid,
+            'timestamp' => $this->getTimestampMs(),
+            'clock' => $this->clock,
+            'datetime' => $this->getDateTime(),
+        ];
+    }
+}
diff --git a/src/Framework/Ulid/UlidGenerator.php b/src/Framework/Ulid/UlidGenerator.php
new file mode 100644
index 00000000..e2fedd17
--- /dev/null
+++ b/src/Framework/Ulid/UlidGenerator.php
@@ -0,0 +1,22 @@
+<?php
+
+namespace App\Framework\Ulid;
+
+use App\Framework\DateTime\Clock;
+
+final readonly class UlidGenerator
+{
+    public function generate(Clock $clock): string
+    {
+        $stringConverter = new StringConverter();
+
+        $timestamp = $clock->now()->getTimestamp() . $clock->now()->getMicrosecond();
+        $time = (int)$timestamp /1000;
+        #$time = (int)(microtime(true) * 1000);
+        $timeBin = substr(pack('J', $time), 2, 6);
+        $random  = random_bytes(10);
+        $bin     = $timeBin . $random;
+
+        return $stringConverter->encodeBase32($bin);
+    }
+}
diff --git a/src/Framework/Ulid/UlidParser.php b/src/Framework/Ulid/UlidParser.php
new file mode 100644
index 00000000..678f6db9
--- /dev/null
+++ b/src/Framework/Ulid/UlidParser.php
@@ -0,0 +1,72 @@
+<?php
+
+namespace App\Framework\Ulid;
+
+use App\Framework\DateTime\Clock;
+use DateTimeImmutable;
+use InvalidArgumentException;
+use RuntimeException;
+
+/**
+ * Extrahiert Zeitstempel aus einer validen ULID.
+ */
+final readonly class UlidParser
+{
+    public function __construct(
+        private ULIDValidator $validator
+    ){}
+
+    /**
+     * @param string $ulid
+     * @return int Millisekunden seit Unix-Epoch
+     * @throws InvalidArgumentException
+     */
+    public function getTimestampMs(string $ulid): int
+    {
+        if (! $this->validator->isValid($ulid)) {
+            throw new InvalidArgumentException("Ungültige ULID: $ulid");
+        }
+
+        // erste 10 Zeichen = 10×5=50 Bit, wir brauchen die ersten 48 Bit
+        $bits = '';
+        for ($i = 0; $i < 10; $i++) {
+            $bits .= str_pad(decbin($this->charValue($ulid[$i])), 5, '0', STR_PAD_LEFT);
+        }
+        $timeBits = substr($bits, 0, 48);
+        return bindec($timeBits);
+    }
+
+    /**
+     * @param string $ulid
+     * @param Clock $clock
+     * @return DateTimeImmutable
+     */
+    public function getDateTime(string $ulid, Clock $clock): DateTimeImmutable
+    {
+        $ms = $this->getTimestampMs($ulid);
+        $sec = floor($ms / 1000);
+        $usec = ($ms % 1000) * 1000;
+        return $clock->fromString(sprintf("%d %06d", $sec, $usec), 'U u');
+    }
+
+    /**
+     * Converts a Base32 character into its corresponding integer value.
+     *
+     * @param string $char The Base32 character to convert.
+     * @return int The integer value of the specified Base32 character.
+     * @throws InvalidArgumentException If the provided character is not a valid Base32 character.
+     */
+    private function charValue(string $char): int
+    {
+        static $map = null;
+        if ($map === null) {
+            $alphabet = '0123456789ABCDEFGHJKMNPQRSTVWXYZ';
+            $map = array_flip(str_split($alphabet));
+        }
+        $upper = strtoupper($char);
+        if (! isset($map[$upper])) {
+            throw new InvalidArgumentException("Ungültiges Base32-Zeichen: $char");
+        }
+        return $map[$upper];
+    }
+}
diff --git a/src/Framework/Ulid/UlidValidator.php b/src/Framework/Ulid/UlidValidator.php
new file mode 100644
index 00000000..28233ea5
--- /dev/null
+++ b/src/Framework/Ulid/UlidValidator.php
@@ -0,0 +1,18 @@
+<?php
+
+namespace App\Framework\Ulid;
+
+/**
+ * Validiert ULID-Strings.
+ */
+final readonly class UlidValidator
+{
+    /**
+     * @param string $ulid
+     * @return bool true, wenn $ulid exakt 26 Zeichen Crockford-Base32 sind
+     */
+    public function isValid(string $ulid): bool
+    {
+        return (bool) preg_match('/^[0-9A-HJKMNP-TV-Z]{26}$/', $ulid);
+    }
+}
diff --git a/src/Framework/Validation/Exceptions/ValidationException.php b/src/Framework/Validation/Exceptions/ValidationException.php
new file mode 100644
index 00000000..647804b5
--- /dev/null
+++ b/src/Framework/Validation/Exceptions/ValidationException.php
@@ -0,0 +1,116 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Validation\Exceptions;
+
+use App\Framework\Exception\FrameworkException;
+use App\Framework\Validation\ValidationResult;
+
+final class ValidationException extends FrameworkException
+{
+    public readonly ValidationResult $validationResult;
+    public readonly array $errors;
+    public readonly string $field;
+
+    /**
+     * @param ValidationResult $validationResult Das Validierungsergebnis mit allen Fehlern
+     * @param string|null $field Optionaler einzelner Feldname für Rückwärtskompatibilität
+     */
+    public function __construct(
+        ValidationResult $validationResult,
+        ?string $field = null
+    ) {
+        $this->validationResult = $validationResult;
+
+        // Für Rückwärtskompatibilität: Wenn nur ein Feld angegeben wurde, verwende dessen Fehler
+        if ($field !== null && $validationResult->getFieldErrors($field)) {
+            $this->field = $field;
+            $this->errors = $validationResult->getFieldErrors($field);
+        } else {
+            // Andernfalls verwende das erste Feld oder einen Standard
+            $allErrors = $validationResult->getAll();
+            $firstField = array_key_first($allErrors);
+            $this->field = $firstField ?? 'unknown';
+            $this->errors = $firstField ? $allErrors[$firstField] : [];
+        }
+
+        // Erstelle eine aussagekräftige Fehlernachricht aus allen Fehlern
+        $message = $this->createErrorMessage();
+
+        parent::__construct(message: $message);
+    }
+
+    /**
+     * Erstellt eine strukturierte Fehlernachricht aus allen Validierungsfehlern
+     */
+    private function createErrorMessage(): string
+    {
+        $allErrors = $this->validationResult->getAll();
+
+        if (empty($allErrors)) {
+            return 'Unbekannter Validierungsfehler.';
+        }
+
+        $messages = [];
+        foreach ($allErrors as $field => $fieldErrors) {
+            $fieldMessage = $field . ': ' . implode(', ', $fieldErrors);
+            $messages[] = $fieldMessage;
+        }
+
+        return implode('; ', $messages);
+    }
+
+    /**
+     * Gibt alle Fehlermeldungen für ein bestimmtes Feld zurück
+     *
+     * @param string $field Feldname
+     * @return array<string> Liste der Fehlermeldungen für das Feld
+     */
+    public function getFieldErrors(string $field): array
+    {
+        return $this->validationResult->getFieldErrors($field);
+    }
+
+    /**
+     * Gibt alle Fehlermeldungen als Array zurück
+     *
+     * @return array<string, string[]> Alle Fehlermeldungen gruppiert nach Feldern
+     */
+    public function getAllErrors(): array
+    {
+        return $this->validationResult->getAll();
+    }
+
+    /**
+     * Gibt alle Fehlermeldungen als flache Liste zurück
+     *
+     * @return array<string> Liste aller Fehlermeldungen
+     */
+    public function getAllErrorMessages(): array
+    {
+        return $this->validationResult->getAllErrorMessages();
+    }
+
+    /**
+     * Prüft, ob ein bestimmtes Feld Fehler hat
+     */
+    public function hasFieldErrors(string $field): bool
+    {
+        return !empty($this->validationResult->getFieldErrors($field));
+    }
+
+    /**
+     * Statische Factory-Methode für einfache Einzelfeld-Fehler (Rückwärtskompatibilität)
+     *
+     * @param array<string> $errors Liste der Fehlermeldungen
+     * @param string $field Feldname
+     * @return self
+     */
+    public static function forField(array $errors, string $field): self
+    {
+        $validationResult = new ValidationResult();
+        $validationResult->addErrors($field, $errors);
+
+        return new self($validationResult, $field);
+    }
+}
diff --git a/src/Framework/Validation/GroupAware.php b/src/Framework/Validation/GroupAware.php
new file mode 100644
index 00000000..f6f0ed83
--- /dev/null
+++ b/src/Framework/Validation/GroupAware.php
@@ -0,0 +1,15 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Validation;
+
+/**
+ * Interface für Validierungsregeln, die zu bestimmten Gruppen gehören können
+ */
+interface GroupAware
+{
+    /**
+     * Prüft, ob das Attribut zu einer bestimmten Validierungsgruppe gehört
+     */
+    public function belongsToGroup(string $group): bool;
+}
diff --git a/src/Framework/Validation/Rules/Custom.php b/src/Framework/Validation/Rules/Custom.php
new file mode 100644
index 00000000..931b9b26
--- /dev/null
+++ b/src/Framework/Validation/Rules/Custom.php
@@ -0,0 +1,35 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Validation\Rules;
+
+use App\Framework\Validation\ValidationRule;
+use Attribute;
+use Closure;
+
+#[Attribute(Attribute::TARGET_PROPERTY | Attribute::TARGET_PARAMETER)]
+final readonly class Custom implements ValidationRule
+{
+    /**
+     * @param callable $validator Funktion zur Validierung (erhält den Wert und gibt bool zurück)
+     * @param array<string> $messages Fehlermeldungen
+     */
+    public function __construct(
+        private Closure $validator,
+        private array   $messages = ['Der angegebene Wert ist ungültig.']
+    ) {
+        if (!is_callable($validator)) {
+            throw new \InvalidArgumentException('Der Validator muss eine aufrufbare Funktion sein.');
+        }
+    }
+
+    public function validate(mixed $value): bool
+    {
+        return ($this->validator)($value);
+    }
+
+    public function getErrorMessages(): array
+    {
+        return $this->messages;
+    }
+}
diff --git a/src/Framework/Validation/Rules/Email.php b/src/Framework/Validation/Rules/Email.php
new file mode 100644
index 00000000..d4a48d28
--- /dev/null
+++ b/src/Framework/Validation/Rules/Email.php
@@ -0,0 +1,32 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Validation\Rules;
+
+use App\Framework\Validation\ValidationRule;
+use Attribute;
+
+#[Attribute(Attribute::TARGET_PROPERTY | Attribute::TARGET_PARAMETER)]
+final class Email implements ValidationRule
+{
+    /**
+     * @param string|null $message Benutzerdefinierte Fehlermeldung
+     */
+    public function __construct(
+        private ?string $message = null
+    ) {}
+
+    public function validate(mixed $value): bool
+    {
+        if ($value === null || $value === '') {
+            return true; // Leere Werte werden von Required-Regel behandelt
+        }
+
+        return filter_var($value, FILTER_VALIDATE_EMAIL) !== false;
+    }
+
+    public function getErrorMessages(): array
+    {
+        return [$this->message ?? 'Bitte geben Sie eine gültige E-Mail-Adresse ein.'];
+    }
+}
diff --git a/src/Framework/Validation/Rules/In.php b/src/Framework/Validation/Rules/In.php
new file mode 100644
index 00000000..6d328611
--- /dev/null
+++ b/src/Framework/Validation/Rules/In.php
@@ -0,0 +1,46 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Validation\Rules;
+
+use App\Framework\Validation\ValidationRule;
+use Attribute;
+
+#[Attribute(Attribute::TARGET_PROPERTY | Attribute::TARGET_PARAMETER)]
+final class In implements ValidationRule
+{
+    private array $values;
+
+    /**
+     * @param array $values Erlaubte Werte
+     * @param string|null $message Benutzerdefinierte Fehlermeldung
+     */
+    public function __construct(
+        array $values,
+        private ?string $message = null
+    ) {
+        if (empty($values)) {
+            throw new \InvalidArgumentException('Die Liste der erlaubten Werte darf nicht leer sein.');
+        }
+        $this->values = $values;
+    }
+
+    public function validate(mixed $value): bool
+    {
+        if ($value === null || $value === '') {
+            return true; // Leere Werte werden von Required-Regel behandelt
+        }
+
+        return in_array($value, $this->values, true);
+    }
+
+    public function getErrorMessages(): array
+    {
+        if ($this->message !== null) {
+            return [$this->message];
+        }
+
+        $valuesList = implode(', ', array_map(fn($v) => "'$v'", $this->values));
+        return ["Dieser Wert muss einer der folgenden sein: $valuesList."];
+    }
+}
diff --git a/src/Framework/Validation/Rules/IsTrue.php b/src/Framework/Validation/Rules/IsTrue.php
new file mode 100644
index 00000000..c73d3bd4
--- /dev/null
+++ b/src/Framework/Validation/Rules/IsTrue.php
@@ -0,0 +1,26 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Validation\Rules;
+
+use App\Framework\Validation\ValidationRule;
+use Attribute;
+
+#[Attribute(Attribute::TARGET_PROPERTY | Attribute::TARGET_PARAMETER)]
+final class IsTrue implements ValidationRule
+{
+
+    public function validate(mixed $value): bool
+    {
+        if (is_bool($value)) {
+            return $value;
+        }
+
+        return false;
+    }
+
+    public function getErrorMessages(): array
+    {
+        return ['Dieser Wert muss "true" sein.'];
+    }
+}
diff --git a/src/Framework/Validation/Rules/Numeric.php b/src/Framework/Validation/Rules/Numeric.php
new file mode 100644
index 00000000..d36be0a3
--- /dev/null
+++ b/src/Framework/Validation/Rules/Numeric.php
@@ -0,0 +1,32 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Validation\Rules;
+
+use App\Framework\Validation\ValidationRule;
+use Attribute;
+
+#[Attribute(Attribute::TARGET_PROPERTY | Attribute::TARGET_PARAMETER)]
+final readonly class Numeric implements ValidationRule
+{
+    /**
+     * @param string|null $message Benutzerdefinierte Fehlermeldung
+     */
+    public function __construct(
+        private ?string $message = null
+    ) {}
+
+    public function validate(mixed $value): bool
+    {
+        if ($value === null || $value === '') {
+            return true; // Leere Werte werden von Required-Regel behandelt
+        }
+
+        return is_numeric($value);
+    }
+
+    public function getErrorMessages(): array
+    {
+        return [$this->message ?? 'Dieser Wert muss numerisch sein.'];
+    }
+}
diff --git a/src/Framework/Validation/Rules/Pattern.php b/src/Framework/Validation/Rules/Pattern.php
new file mode 100644
index 00000000..234cd62e
--- /dev/null
+++ b/src/Framework/Validation/Rules/Pattern.php
@@ -0,0 +1,38 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Validation\Rules;
+
+use App\Framework\Validation\ValidationRule;
+use Attribute;
+
+#[Attribute(Attribute::TARGET_PROPERTY | Attribute::TARGET_PARAMETER)]
+final readonly class Pattern implements ValidationRule
+{
+    /**
+     * @param string $pattern Regulärer Ausdruck
+     * @param string|null $message Benutzerdefinierte Fehlermeldung
+     */
+    public function __construct(
+        private string  $pattern,
+        private ?string $message = null
+    ) {}
+
+    public function validate(mixed $value): bool
+    {
+        if ($value === null || $value === '') {
+            return true; // Leere Werte werden von Required-Regel behandelt
+        }
+
+        if (!is_string($value)) {
+            return false;
+        }
+
+        return preg_match($this->pattern, $value) === 1;
+    }
+
+    public function getErrorMessages(): array
+    {
+        return [$this->message ?? 'Dieser Wert entspricht nicht dem erforderlichen Format.'];
+    }
+}
diff --git a/src/Framework/Validation/Rules/Range.php b/src/Framework/Validation/Rules/Range.php
new file mode 100644
index 00000000..1c190b67
--- /dev/null
+++ b/src/Framework/Validation/Rules/Range.php
@@ -0,0 +1,62 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Validation\Rules;
+
+use App\Framework\Validation\ValidationRule;
+use Attribute;
+
+#[Attribute(Attribute::TARGET_PROPERTY | Attribute::TARGET_PARAMETER)]
+final readonly class Range implements ValidationRule
+{
+    /**
+     * @param float|null $min Minimaler Wert
+     * @param float|null $max Maximaler Wert
+     * @param string|null $message Benutzerdefinierte Fehlermeldung
+     */
+    public function __construct(
+        private ?float  $min = null,
+        private ?float  $max = null,
+        private ?string $message = null
+    ) {
+        if ($min === null && $max === null) {
+            throw new \InvalidArgumentException('Mindestens einer der Parameter min oder max muss gesetzt sein.');
+        }
+    }
+
+    public function validate(mixed $value): bool
+    {
+        if ($value === null || $value === '') {
+            return true; // Leere Werte werden von Required-Regel behandelt
+        }
+
+        if (!is_numeric($value)) {
+            return false;
+        }
+
+        if ($this->min !== null && $value < $this->min) {
+            return false;
+        }
+
+        if ($this->max !== null && $value > $this->max) {
+            return false;
+        }
+
+        return true;
+    }
+
+    public function getErrorMessages(): array
+    {
+        if ($this->message !== null) {
+            return [$this->message];
+        }
+
+        if ($this->min !== null && $this->max !== null) {
+            return ["Dieser Wert muss zwischen {$this->min} und {$this->max} liegen."];
+        } elseif ($this->min !== null) {
+            return ["Dieser Wert muss mindestens {$this->min} sein."];
+        } else {
+            return ["Dieser Wert darf maximal {$this->max} sein."];
+        }
+    }
+}
diff --git a/src/Framework/Validation/Rules/Required.php b/src/Framework/Validation/Rules/Required.php
new file mode 100644
index 00000000..5f881963
--- /dev/null
+++ b/src/Framework/Validation/Rules/Required.php
@@ -0,0 +1,28 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Validation\Rules;
+
+use App\Framework\Validation\ValidationRule;
+use Attribute;
+
+#[Attribute(Attribute::TARGET_PROPERTY | Attribute::TARGET_PARAMETER)]
+final readonly class Required implements ValidationRule
+{
+    /**
+     * @param string|null $message Benutzerdefinierte Fehlermeldung
+     */
+    public function __construct(
+        private ?string $message = null
+    ) {}
+
+    public function validate(mixed $value): bool
+    {
+        return $value !== null && $value !== '';
+    }
+
+    public function getErrorMessages(): array
+    {
+        return [$this->message ?? 'Dieser Wert ist erforderlich.'];
+    }
+}
diff --git a/src/Framework/Validation/Rules/StringLength.php b/src/Framework/Validation/Rules/StringLength.php
new file mode 100644
index 00000000..a0cb25ef
--- /dev/null
+++ b/src/Framework/Validation/Rules/StringLength.php
@@ -0,0 +1,64 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Validation\Rules;
+
+use App\Framework\Validation\ValidationRule;
+use Attribute;
+
+#[Attribute(Attribute::TARGET_PROPERTY | Attribute::TARGET_PARAMETER)]
+final readonly class StringLength implements ValidationRule
+{
+    /**
+     * @param int|null $min Minimale Länge des Strings
+     * @param int|null $max Maximale Länge des Strings
+     * @param string|null $message Benutzerdefinierte Fehlermeldung
+     */
+    public function __construct(
+        private ?int    $min = null,
+        private ?int    $max = null,
+        private ?string $message = null
+    ) {
+        if ($min === null && $max === null) {
+            throw new \InvalidArgumentException('Mindestens einer der Parameter min oder max muss gesetzt sein.');
+        }
+    }
+
+    public function validate(mixed $value): bool
+    {
+        if ($value === null || $value === '') {
+            return true; // Leere Werte werden von Required-Regel behandelt
+        }
+
+        if (!is_string($value)) {
+            return false;
+        }
+
+        $length = mb_strlen($value);
+
+        if ($this->min !== null && $length < $this->min) {
+            return false;
+        }
+
+        if ($this->max !== null && $length > $this->max) {
+            return false;
+        }
+
+        return true;
+    }
+
+    public function getErrorMessages(): array
+    {
+        if ($this->message !== null) {
+            return [$this->message];
+        }
+
+        if ($this->min !== null && $this->max !== null) {
+            return ["Dieser Wert muss zwischen {$this->min} und {$this->max} Zeichen lang sein."];
+        } elseif ($this->min !== null) {
+            return ["Dieser Wert muss mindestens {$this->min} Zeichen lang sein."];
+        } else {
+            return ["Dieser Wert darf maximal {$this->max} Zeichen lang sein."];
+        }
+    }
+}
diff --git a/src/Framework/Validation/Rules/ValidationGroup.php b/src/Framework/Validation/Rules/ValidationGroup.php
new file mode 100644
index 00000000..4cbab13f
--- /dev/null
+++ b/src/Framework/Validation/Rules/ValidationGroup.php
@@ -0,0 +1,31 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Validation\Rules;
+
+use App\Framework\Validation\GroupAware;
+use App\Framework\Validation\ValidationRule;
+use Attribute;
+
+#[Attribute(Attribute::TARGET_CLASS | Attribute::TARGET_PROPERTY | Attribute::TARGET_PARAMETER)]
+final class ValidationGroup implements GroupAware
+{
+    /** @var array<string> */
+    private array $groups;
+
+    /**
+     * @param string|array<string> $groups Name der Gruppe oder Gruppen
+     */
+    public function __construct(string|array $groups)
+    {
+        $this->groups = is_array($groups) ? $groups : [$groups];
+    }
+
+    /**
+     * Prüft, ob das Attribut zu einer bestimmten Gruppe gehört
+     */
+    public function belongsToGroup(string $group): bool
+    {
+        return in_array($group, $this->groups, true);
+    }
+}
diff --git a/src/Framework/Validation/ValidationErrorMiddleware.php b/src/Framework/Validation/ValidationErrorMiddleware.php
new file mode 100644
index 00000000..b93e5b13
--- /dev/null
+++ b/src/Framework/Validation/ValidationErrorMiddleware.php
@@ -0,0 +1,72 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Validation;
+
+use App\Framework\Http\Headers;
+use App\Framework\Http\HttpMiddleware;
+use App\Framework\Http\HttpResponse;
+use App\Framework\Http\MiddlewareContext;
+use App\Framework\Http\MiddlewarePriority;
+use App\Framework\Http\MiddlewarePriorityAttribute;
+use App\Framework\Http\RequestStateManager;
+use App\Framework\Http\Responses\JsonResponse;
+use App\Framework\Http\Responses\RedirectResponse;
+use App\Framework\Http\ServerKey;
+use App\Framework\Http\Session\Session;
+use App\Framework\Http\Status;
+use App\Framework\Validation\Exceptions\ValidationException;
+
+#[MiddlewarePriorityAttribute(MiddlewarePriority::SESSION, -50)]
+final readonly class ValidationErrorMiddleware implements HttpMiddleware
+{
+    public function __construct(
+        private Session $session
+    ) {}
+    public function __invoke(MiddlewareContext $context, callable $next, RequestStateManager $stateManager): MiddlewareContext
+    {
+        try {
+            return $next($context);
+        } catch (ValidationException $e) {
+
+            // Speichern des Formulars in der Session
+            $this->session->form->store('form', $context->request->parsedBody->data);
+
+            // Speichern der Validierungsfehler in der Session
+            $this->session->validation->add('form', $e->getAllErrors());;
+
+            return $this->createValidationErrorResponse($context, $e);
+        }
+    }
+
+    /**
+     * Erstellt eine Fehlerantwort für Validierungsfehler
+     */
+    private function createValidationErrorResponse(MiddlewareContext $context, ValidationException $e): MiddlewareContext
+    {
+        $acceptHeader = $context->request->server->get(ServerKey::HTTP_ACCEPT, '');
+
+        // Formatierung der Fehlerantwort je nach Content-Type
+        //$acceptHeader = $_SERVER['HTTP_ACCEPT'] ?? '';
+
+        if (str_contains($acceptHeader, 'application/json')) {
+            // JSON-Antwort für API-Anfragen
+
+            return $context->withResponse(
+                new JsonResponse(
+                    body: [
+                        'error' => 'Validation Error',
+                        'message' => $e->getMessage(),
+                        'errors' => $e->getAllErrors(),//$this->formatErrors($e),
+                    ],
+                    status: Status::UNPROCESSABLE_ENTITY,
+                ),
+            );
+        } else {
+
+            $uri = $context->request->server->getRefererUri();
+
+            return $context->withResponse(new RedirectResponse($uri));
+        }
+    }
+}
diff --git a/src/Framework/Validation/ValidationResult.php b/src/Framework/Validation/ValidationResult.php
new file mode 100644
index 00000000..83fb8cee
--- /dev/null
+++ b/src/Framework/Validation/ValidationResult.php
@@ -0,0 +1,84 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Validation;
+
+final class ValidationResult
+{
+    /** @var array<string, string[]> */
+    private array $errors = [];
+
+    /**
+     * Fügt eine Fehlermeldung für ein Feld hinzu
+     */
+    public function addError(string $field, string $message): void
+    {
+        $this->errors[$field][] = $message;
+    }
+
+    /**
+     * Fügt mehrere Fehlermeldungen für ein Feld hinzu
+     *
+     * @param string $field Feldname
+     * @param array<string> $messages Liste von Fehlermeldungen
+     */
+    public function addErrors(string $field, array $messages): void
+    {
+        foreach ($messages as $message) {
+            $this->addError($field, $message);
+        }
+    }
+
+    /**
+     * Prüft, ob Fehler vorhanden sind
+     */
+    public function hasErrors(): bool
+    {
+        return !empty($this->errors);
+    }
+
+    /**
+     * Gibt alle Fehlermeldungen für ein bestimmtes Feld zurück
+     *
+     * @param string $field Feldname
+     * @return array<string> Liste der Fehlermeldungen für das Feld
+     */
+    public function getFieldErrors(string $field): array
+    {
+        return $this->errors[$field] ?? [];
+    }
+
+    /**
+     * Gibt alle Fehlermeldungen als flache Liste zurück
+     *
+     * @return array<string> Liste aller Fehlermeldungen
+     */
+    public function getAllErrorMessages(): array
+    {
+        $messages = [];
+        foreach ($this->errors as $fieldErrors) {
+            foreach ($fieldErrors as $error) {
+                $messages[] = $error;
+            }
+        }
+        return $messages;
+    }
+
+    /**
+     * Kombiniert zwei Validierungsergebnisse
+     */
+    public function merge(ValidationResult $other): self
+    {
+        foreach ($other->errors as $field => $messages) {
+            foreach ($messages as $message) {
+                $this->addError($field, $message);
+            }
+        }
+        return $this;
+    }
+
+    public function getAll():array
+    {
+        return $this->errors;
+    }
+}
diff --git a/src/Framework/Validation/ValidationRule.php b/src/Framework/Validation/ValidationRule.php
new file mode 100644
index 00000000..04f96201
--- /dev/null
+++ b/src/Framework/Validation/ValidationRule.php
@@ -0,0 +1,18 @@
+<?php
+
+namespace App\Framework\Validation;
+
+interface ValidationRule
+{
+    /**
+     * Validiert einen Wert anhand der Regel
+     */
+    public function validate(mixed $value): bool;
+
+    /**
+     * Gibt alle Fehlermeldungen für diese Regel zurück
+     *
+     * @return array<string> Liste der Fehlermeldungen
+     */
+    public function getErrorMessages(): array;
+}
diff --git a/src/Framework/Validation/Validator.php b/src/Framework/Validation/Validator.php
new file mode 100644
index 00000000..b663a39b
--- /dev/null
+++ b/src/Framework/Validation/Validator.php
@@ -0,0 +1,71 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Validation;
+
+use ReflectionClass;
+
+final class Validator
+{
+    /**
+     * Validiert ein Objekt und gibt das Ergebnis zurück
+     *
+     * @param object $object Das zu validierende Objekt
+     * @param string|null $group Optionale Validierungsgruppe
+     * @return ValidationResult
+     */
+    public function validate(object $object, ?string $group = null): ValidationResult
+    {
+        $result = new ValidationResult();
+        $refClass = new ReflectionClass($object);
+
+        // Eigenschaften validieren
+        foreach ($refClass->getProperties() as $property) {
+
+            try {
+
+                if(!$property?->isInitialized($object) && !$property->getType()?->allowsNull()){
+
+                    $result->addError(
+                        $property->getName(),
+                        sprintf("Feld '%s' darf nicht null sein.", $property->getName())
+                    );
+
+                    continue;
+                }
+
+
+                $value = $property->getValue($object);
+            } catch (\Throwable) {
+
+                //$result->addError($property->getName(), 'Fehler beim Lesen des Werts');
+                continue;
+            }
+
+
+            foreach ($property->getAttributes() as $attribute) {
+                $attrInstance = $attribute->newInstance();
+
+
+                if ($attrInstance instanceof ValidationRule) {
+                    $shouldValidate = false;
+
+                    if ($group === null) {
+                        $shouldValidate = true;
+                    } elseif ($attrInstance instanceof GroupAware) {
+                        $shouldValidate = $attrInstance->belongsToGroup($group);
+                    } else {
+                        $shouldValidate = true;
+                    }
+
+                    if ($shouldValidate && !$attrInstance->validate($value)) {
+                        $result->addErrors($property->getName(), $attrInstance->getErrorMessages());
+                    }
+                }
+            }
+
+        }
+
+        return $result;
+    }
+}
diff --git a/src/Framework/View/Caching/Analysis/CacheStrategy.php b/src/Framework/View/Caching/Analysis/CacheStrategy.php
new file mode 100644
index 00000000..7af7a76a
--- /dev/null
+++ b/src/Framework/View/Caching/Analysis/CacheStrategy.php
@@ -0,0 +1,39 @@
+<?php
+
+namespace App\Framework\View\Caching\Analysis;
+
+enum CacheStrategy: string
+{
+    case FULL_PAGE = 'full_page';
+    case COMPONENT = 'component';
+    case FRAGMENT = 'fragment';
+    case USER_AWARE = 'user_aware';
+    case NO_CACHE = 'no_cache';
+
+    public function getTtl(): int
+    {
+        return match($this) {
+            self::FULL_PAGE => 3600,    // 1 hour
+            self::COMPONENT => 1800,    // 30 minutes
+            self::FRAGMENT => 900,      // 15 minutes
+            self::USER_AWARE => 300,    // 5 minutes
+            self::NO_CACHE => 0,        // No caching
+        };
+    }
+
+    public function shouldCache(): bool
+    {
+        return $this !== self::NO_CACHE;
+    }
+
+    public function getDescription(): string
+    {
+        return match($this) {
+            self::FULL_PAGE => 'Full page caching for static content',
+            self::COMPONENT => 'Component-level caching for reusable parts',
+            self::FRAGMENT => 'Fragment-based caching for mixed content',
+            self::USER_AWARE => 'User-specific caching with short TTL',
+            self::NO_CACHE => 'No caching for fully dynamic content',
+        };
+    }
+}
diff --git a/src/Framework/View/Caching/Analysis/CacheabilityAnalyzer.php b/src/Framework/View/Caching/Analysis/CacheabilityAnalyzer.php
new file mode 100644
index 00000000..8ef2ec47
--- /dev/null
+++ b/src/Framework/View/Caching/Analysis/CacheabilityAnalyzer.php
@@ -0,0 +1,40 @@
+<?php
+
+namespace App\Framework\View\Caching\Analysis;
+
+class CacheabilityAnalyzer
+{
+    public function analyze(string $content): CacheabilityScore
+    {
+        $score = new CacheabilityScore();
+
+        // Faktoren die Cacheability beeinflussen
+        $score->hasUserSpecificContent = $this->hasUserContent($content);
+        $score->hasCsrfTokens = $this->hasCsrfTokens($content);
+        $score->hasTimestamps = $this->hasTimestamps($content);
+        $score->hasRandomElements = $this->hasRandomElements($content);
+        $score->staticContentRatio = $this->calculateStaticRatio($content);
+
+        return $score;
+    }
+
+    private function hasUserContent(string $content)
+    {
+    }
+
+    private function hasCsrfTokens(string $content)
+    {
+    }
+
+    private function hasTimestamps(string $content)
+    {
+    }
+
+    private function hasRandomElements(string $content)
+    {
+    }
+
+    private function calculateStaticRatio(string $content)
+    {
+    }
+}
diff --git a/src/Framework/View/Caching/Analysis/CacheabilityScore.php b/src/Framework/View/Caching/Analysis/CacheabilityScore.php
new file mode 100644
index 00000000..194ebc1d
--- /dev/null
+++ b/src/Framework/View/Caching/Analysis/CacheabilityScore.php
@@ -0,0 +1,29 @@
+<?php
+
+namespace App\Framework\View\Caching\Analysis;
+
+class CacheabilityScore
+{
+    public bool $hasUserSpecificContent = false;
+    public bool $hasCsrfTokens = false;
+    public bool $hasTimestamps = false;
+    public bool $hasRandomElements = false;
+    public float $staticContentRatio = 0.0;
+
+    public function getScore(): float
+    {
+        $score = $this->staticContentRatio;
+
+        if ($this->hasUserSpecificContent) $score -= 0.3;
+        if ($this->hasCsrfTokens) $score -= 0.2;
+        if ($this->hasTimestamps) $score -= 0.1;
+        if ($this->hasRandomElements) $score -= 0.2;
+
+        return max(0, min(1, $score));
+    }
+
+    public function isCacheable(): bool
+    {
+        return $this->getScore() > 0.5;
+    }
+}
diff --git a/src/Framework/View/Caching/Analysis/SmartTemplateAnalyzer.php b/src/Framework/View/Caching/Analysis/SmartTemplateAnalyzer.php
new file mode 100644
index 00000000..eff851d1
--- /dev/null
+++ b/src/Framework/View/Caching/Analysis/SmartTemplateAnalyzer.php
@@ -0,0 +1,171 @@
+<?php
+
+namespace App\Framework\View\Caching\Analysis;
+
+use App\Framework\View\Loading\TemplateLoader;
+
+final readonly class SmartTemplateAnalyzer implements TemplateAnalyzer
+{
+    public function __construct(
+        private TemplateLoader $loader,
+    ) {}
+
+    public function analyze(string $template): TemplateAnalysis
+    {
+        try {
+            $content = $this->loader->load($template);
+        } catch (\Throwable $e) {
+            return $this->createFallbackAnalysis($template);
+        }
+
+        $dependencies = $this->getDependencies($template);
+        $cacheability = $this->getCacheability($template);
+        $fragments = $this->findFragments($content);
+
+        $strategy = $this->determineOptimalStrategy($template, $cacheability, $dependencies);
+        $ttl = $this->calculateOptimalTtl($strategy, $cacheability);
+
+        return new TemplateAnalysis($template, $strategy, $ttl, $dependencies, $cacheability, $fragments);
+    }
+
+    public function getDependencies(string $template): array
+    {
+        try {
+            $content = $this->loader->load($template);
+            $dependencies = [];
+
+            // Finde @include directives
+            if (preg_match_all('/@include\s*\([\'"](.+?)[\'"]\)/', $content, $matches)) {
+                $dependencies['includes'] = $matches[1];
+            }
+
+            // Finde <component> tags
+            if (preg_match_all('/<component[^>]*name=[\'"]([^\'"]+)[\'"]/', $content, $matches)) {
+                $dependencies['components'] = $matches[1];
+            }
+
+            return $dependencies;
+        } catch (\Exception $e) {
+            return [];
+        }
+    }
+
+    public function getCacheability(string $template): CacheabilityScore
+    {
+        try {
+            $content = $this->loader->load($template);
+            $score = new CacheabilityScore();
+
+            // Analysiere Content
+            $score->hasUserSpecificContent = $this->hasUserContent($content);
+            $score->hasCsrfTokens = $this->hasCsrfTokens($content);
+            $score->hasTimestamps = $this->hasTimestamps($content);
+            $score->hasRandomElements = $this->hasRandomElements($content);
+            $score->staticContentRatio = $this->calculateStaticRatio($content);
+
+            return $score;
+        } catch (\Exception $e) {
+            return new CacheabilityScore();
+        }
+    }
+
+    private function determineOptimalStrategy(string $template, CacheabilityScore $cacheability, array $dependencies): CacheStrategy
+    {
+        // Nicht cacheable = NoCache
+        if (!$cacheability->isCacheable()) {
+            return CacheStrategy::NO_CACHE;
+        }
+
+        // Components
+        if (str_contains($template, 'component') || str_contains($template, 'partial')) {
+            return CacheStrategy::COMPONENT;
+        }
+
+        // Layouts und statische Seiten
+        if (str_contains($template, 'layout') || $cacheability->staticContentRatio > 0.8) {
+            return CacheStrategy::FULL_PAGE;
+        }
+
+        // Default: Fragment
+        return CacheStrategy::FRAGMENT;
+    }
+
+    private function calculateOptimalTtl(CacheStrategy $strategy, CacheabilityScore $cacheability): int
+    {
+        $baseTtl = match($strategy) {
+            CacheStrategy::FULL_PAGE => 1800,
+            CacheStrategy::COMPONENT => 900,
+            CacheStrategy::FRAGMENT => 300,
+            default => 0
+        };
+
+        // TTL basierend auf Cacheability Score anpassen
+        return (int) ($baseTtl * $cacheability->getScore());
+    }
+
+    private function findFragments(string $content)
+    {
+        // Vereinfachte Fragment-Erkennung
+        $fragments = [];
+
+        // Finde große statische HTML-Blöcke
+        if (preg_match_all('/<(?:nav|header|footer|aside)[^>]*>(.*?)<\/(?:nav|header|footer|aside)>/s', $content, $matches)) {
+            foreach ($matches[0] as $i => $match) {
+                if (strlen($match) > 200 && !str_contains($match, '{{')) {
+                    $fragments["static_block_{$i}"] = [
+                        'type' => 'static',
+                        'size' => strlen($match),
+                        'cacheable' => true
+                    ];
+                }
+            }
+        }
+
+        return $fragments;
+    }
+
+    private function createFallbackAnalysis(string $template): TemplateAnalysis
+    {
+        return new TemplateAnalysis(
+            $template,
+            CacheStrategy::NO_CACHE,
+            0,
+            [],
+            new CacheabilityScore(),
+            []
+        );
+    }
+
+    private function hasUserContent(string $content): bool
+    {
+        return preg_match('/\{\{\s*(user|auth|current_user)/', $content) > 0;
+    }
+
+    private function hasCsrfTokens(string $content): bool
+    {
+        return preg_match('/\{\{\s*(csrf_token|_token)/', $content) > 0;
+    }
+
+    private function hasTimestamps(string $content): bool
+    {
+        return preg_match('/\{\{\s*(now|timestamp|date\()/', $content) > 0;
+    }
+
+    private function hasRandomElements(string $content): bool
+    {
+        return preg_match('/\{\{\s*(random|rand\(|uuid)/', $content) > 0;
+    }
+
+    private function calculateStaticRatio(string $content): float
+    {
+        $totalLength = strlen($content);
+        if ($totalLength === 0) return 0.0;
+
+        // Entferne alle dynamischen Teile
+        $staticContent = preg_replace('/\{\{.*?\}\}/', '', $content);
+        $staticContent = preg_replace('/@\w+.*?@end\w+/s', '', $staticContent);
+
+        return strlen($staticContent) / $totalLength;
+    }
+
+}
diff --git a/src/Framework/View/Caching/Analysis/TemplateAnalysis.php b/src/Framework/View/Caching/Analysis/TemplateAnalysis.php
new file mode 100644
index 00000000..a2355b35
--- /dev/null
+++ b/src/Framework/View/Caching/Analysis/TemplateAnalysis.php
@@ -0,0 +1,15 @@
+<?php
+
+namespace App\Framework\View\Caching\Analysis;
+
+class TemplateAnalysis
+{
+    public function __construct(
+        public readonly string $template,
+        public readonly CacheStrategy $recommendedStrategy,
+        public readonly int $recommendedTtl,
+        public readonly array $dependencies,
+        public readonly CacheabilityScore $cacheability,
+        public readonly array $fragments
+    ) {}
+}
diff --git a/src/Framework/View/Caching/Analysis/TemplateAnalyzer.php b/src/Framework/View/Caching/Analysis/TemplateAnalyzer.php
new file mode 100644
index 00000000..ff75b23d
--- /dev/null
+++ b/src/Framework/View/Caching/Analysis/TemplateAnalyzer.php
@@ -0,0 +1,10 @@
+<?php
+
+namespace App\Framework\View\Caching\Analysis;
+
+interface TemplateAnalyzer
+{
+    public function analyze(string $template): TemplateAnalysis;
+    public function getDependencies(string $template): array;
+    public function getCacheability(string $template): CacheabilityScore;
+}
diff --git a/src/Framework/View/Caching/CacheDiagnostics.php b/src/Framework/View/Caching/CacheDiagnostics.php
new file mode 100644
index 00000000..4f3d817e
--- /dev/null
+++ b/src/Framework/View/Caching/CacheDiagnostics.php
@@ -0,0 +1,84 @@
+<?php
+
+namespace App\Framework\View\Caching;
+
+use App\Framework\Cache\Cache;
+use App\Framework\View\Caching\Analysis\TemplateAnalyzer;
+
+class CacheDiagnostics
+{
+    private array $metrics = [];
+
+    public function __construct(
+        private CacheManager $cacheManager,
+        private TemplateAnalyzer $analyzer,
+        private Cache $cache
+    ) {}
+
+    public function getPerformanceReport(): array
+    {
+        return [
+            'cache_hit_rate' => $this->calculateHitRate(),
+            'average_render_time' => $this->getAverageRenderTime(),
+            'cache_size' => $this->getCacheSize(),
+            'most_cached_templates' => $this->getMostCachedTemplates(),
+            'cache_strategy_distribution' => $this->getStrategyDistribution(),
+            'memory_usage' => $this->getMemoryUsage(),
+            'recommendations' => $this->generateRecommendations()
+        ];
+    }
+
+    public function analyzeTemplate(string $template): array
+    {
+        $analysis = $this->analyzer->analyze($template);
+
+        return [
+            'template' => $template,
+            'recommended_strategy' => $analysis->recommendedStrategy->name,
+            'recommended_ttl' => $analysis->recommendedTtl,
+            'cacheability_score' => $analysis->cacheability->getScore(),
+            'dependencies' => $analysis->dependencies,
+            'potential_fragments' => $analysis->fragments,
+            'optimization_suggestions' => $this->getOptimizationSuggestions($analysis)
+        ];
+    }
+
+    public function warmupCache(array $templates): array
+    {
+        $results = [];
+
+        foreach ($templates as $template => $contexts) {
+            $results[$template] = [];
+
+            foreach ($contexts as $context) {
+                try {
+                    $templateContext = new TemplateContext($template, $context);
+
+                    // Warmup durch Rendering
+                    $this->cacheManager->render($templateContext, function() {
+                        return "<!-- Warmup content for {$template} -->";
+                    });
+
+                    $results[$template][] = 'success';
+                } catch (\Exception $e) {
+                    $results[$template][] = 'error: ' . $e->getMessage();
+                }
+            }
+        }
+
+        return $results;
+    }
+
+    public function healthCheck(): array
+    {
+        return [
+            'cache_connection' => $this->testCacheConnection(),
+            'template_analyzer' => $this->testTemplateAnalyzer(),
+            'fragment_cache' => $this->testFragmentCache(),
+            'strategy_availability' => $this->testStrategies(),
+            'memory_usage' => $this->checkMemoryUsage(),
+            'disk_space' => $this->checkDiskSpace(),
+            'overall_status' => $this->determineOverallHealth()
+        ];
+    }
+}
diff --git a/src/Framework/View/Caching/CacheManager.php b/src/Framework/View/Caching/CacheManager.php
new file mode 100644
index 00000000..4935cbf3
--- /dev/null
+++ b/src/Framework/View/Caching/CacheManager.php
@@ -0,0 +1,122 @@
+<?php
+
+namespace App\Framework\View\Caching;
+
+use App\Framework\Cache\Cache;
+use App\Framework\View\Caching\Analysis\CacheStrategy;
+use App\Framework\View\Caching\Analysis\TemplateAnalysis;
+use App\Framework\View\Caching\Analysis\TemplateAnalyzer;
+use App\Framework\View\Caching\Strategies\ComponentCacheStrategy;
+use App\Framework\View\Caching\Strategies\FragmentCacheStrategy;
+use App\Framework\View\Caching\Strategies\FullPageCacheStrategy;
+use App\Framework\View\Caching\Strategies\NoCacheStrategy;
+use App\Framework\View\Caching\Strategies\ViewCacheStrategy;
+use App\Framework\View\RenderContext;
+use Archive\Archived\SmartCacheEngine;
+
+class CacheManager
+{
+    private array $strategies = [];
+    private ?TemplateAnalysis $lastAnalysis = null;
+
+    public function __construct(
+        private Cache $cache,
+        private TemplateAnalyzer $analyzer,
+        private FragmentCache $fragmentCache,
+        private array $strategyMapping = []
+    ) {
+        $this->initializeStrategies();
+    }
+
+    public function render(TemplateContext $context, callable $renderer): string
+    {
+        // 1. Template analysieren für optimale Strategy
+        $analysis = $this->analyzer->analyze($context->template);
+        $this->lastAnalysis = $analysis;
+
+        // 2. Passende Strategy auswählen
+        $strategy = $this->selectStrategy($analysis);
+
+        if (!$strategy->shouldCache($context)) {
+            return $renderer();
+        }
+
+        // 3. Cache-Key generieren
+        $cacheKey = $strategy->generateKey($context);
+
+        // 4. Cache-Lookup
+        $cached = $this->cache->get($cacheKey);
+        if ($cached->isHit) {
+            return $cached->value;
+        }
+
+        // 5. Rendern und cachen
+        $content = $renderer();
+        $ttl = $strategy->getTtl($context);
+
+        $this->cache->set($cacheKey, $content, $ttl);
+
+        return $content;
+    }
+
+    public function invalidateTemplate(string $template): int
+    {
+        $invalidated = 0;
+
+        // Invalidiere alle Strategies für dieses Template
+        foreach ($this->strategies as $strategy) {
+            if ($strategy->canInvalidate($template)) {
+                // Pattern-basierte Invalidierung je nach Strategy
+                $pattern = $this->buildInvalidationPattern($strategy, $template);
+                $invalidated += $this->invalidateByPattern($pattern);
+            }
+        }
+
+        return $invalidated;
+    }
+
+    private function selectStrategy(TemplateAnalysis $analysis): ViewCacheStrategy
+    {
+        return match($analysis->recommendedStrategy) {
+            CacheStrategy::FULL_PAGE => $this->strategies['full_page'],
+            CacheStrategy::COMPONENT => $this->strategies['component'],
+            CacheStrategy::FRAGMENT => $this->strategies['fragment'],
+            CacheStrategy::USER_AWARE => $this->strategies['user_aware'],
+            default => $this->strategies['no_cache']
+        };
+    }
+
+    private function initializeStrategies(): void
+    {
+        $this->strategies = [
+            'full_page' => new FullPageCacheStrategy($this->cache),
+            'component' => new ComponentCacheStrategy($this->cache),
+            'fragment' => new FragmentCacheStrategy($this->cache),
+            'no_cache' => new NoCacheStrategy(),
+        ];
+    }
+
+    private function buildInvalidationPattern(mixed $strategy, string $template): string
+    {
+        return match(get_class($strategy)) {
+            FullPageCacheStrategy::class => "page:{$template}:*",
+            ComponentCacheStrategy::class => "component:*{$template}*",
+            FragmentCacheStrategy::class => "fragment:{$template}:*",
+            default => "*{$template}*"
+        };
+    }
+
+    private function invalidateByPattern(null $pattern): int
+    {
+        // Vereinfachte Implementation - in Realität müsste das der Cache-Driver unterstützen
+        // Für jetzt: Cache komplett leeren bei Pattern-Match
+        $invalidated = 0;
+
+        if (str_contains($pattern, '*')) {
+            $this->cache->clear();
+            $invalidated = 1;
+        }
+
+        return $invalidated;
+    }
+}
diff --git a/src/Framework/View/Caching/FragmentCache.php b/src/Framework/View/Caching/FragmentCache.php
new file mode 100644
index 00000000..757429b0
--- /dev/null
+++ b/src/Framework/View/Caching/FragmentCache.php
@@ -0,0 +1,11 @@
+<?php
+
+namespace App\Framework\View\Caching;
+
+interface FragmentCache
+{
+    public function fragment(string $key, callable $generator, int $ttl, array $tags = []): string;
+    public function invalidateFragment(string $key): bool;
+    public function invalidateByTags(array $tags): int;
+    public function hasFragment(string $key): bool;
+}
diff --git a/src/Framework/View/Caching/Keys/SmartKeyGenerator.php b/src/Framework/View/Caching/Keys/SmartKeyGenerator.php
new file mode 100644
index 00000000..2f33868c
--- /dev/null
+++ b/src/Framework/View/Caching/Keys/SmartKeyGenerator.php
@@ -0,0 +1,11 @@
+<?php
+
+namespace App\Framework\View\Caching\Keys;
+
+class SmartKeyGenerator
+{
+
+    public function generate(string $string, string $key)
+    {
+    }
+}
diff --git a/src/Framework/View/Caching/SmartCache.php b/src/Framework/View/Caching/SmartCache.php
new file mode 100644
index 00000000..db4c9350
--- /dev/null
+++ b/src/Framework/View/Caching/SmartCache.php
@@ -0,0 +1,16 @@
+<?php
+
+namespace App\Framework\View\Caching;
+
+use App\Framework\View\RenderContext;
+
+interface SmartCache
+{
+    public function isEnabled(): bool;
+
+    public function render(RenderContext $context, callable $fallbackRenderer): string;
+
+    public function invalidateCache(?string $template = null): int;
+
+    public function getCacheStats(): array;
+}
diff --git a/src/Framework/View/Caching/Strategies/ComponentCacheStrategy.php b/src/Framework/View/Caching/Strategies/ComponentCacheStrategy.php
new file mode 100644
index 00000000..d5cf9b33
--- /dev/null
+++ b/src/Framework/View/Caching/Strategies/ComponentCacheStrategy.php
@@ -0,0 +1,34 @@
+<?php
+
+namespace App\Framework\View\Caching\Strategies;
+
+use App\Framework\Cache\Cache;
+use App\Framework\View\Caching\TemplateContext;
+
+final readonly class ComponentCacheStrategy implements ViewCacheStrategy
+{
+    public function __construct(private Cache $cache) {}
+    public function shouldCache(TemplateContext $context): bool
+    {
+        return str_contains($context->template, 'component') ||
+            str_contains($context->template, 'partial');
+    }
+
+    public function generateKey(TemplateContext $context): string
+    {
+        $component = basename($context->template);
+        $dataHash = md5(serialize($context->data));
+        return "component:{$component}:{$dataHash}";
+    }
+
+    public function getTtl(TemplateContext $context): int
+    {
+        // Komponenten länger cachen da sie wiederverwendbar sind
+        return 1800; // 30 minutes
+    }
+
+    public function canInvalidate(string $template): bool
+    {
+        return str_contains($template, 'component') || str_contains($template, 'partial');
+    }
+}
diff --git a/src/Framework/View/Caching/Strategies/FragmentCacheStrategy.php b/src/Framework/View/Caching/Strategies/FragmentCacheStrategy.php
new file mode 100644
index 00000000..da7571b1
--- /dev/null
+++ b/src/Framework/View/Caching/Strategies/FragmentCacheStrategy.php
@@ -0,0 +1,32 @@
+<?php
+
+namespace App\Framework\View\Caching\Strategies;
+
+use App\Framework\Cache\Cache;
+use App\Framework\View\Caching\TemplateContext;
+
+class FragmentCacheStrategy implements ViewCacheStrategy
+{
+    public function __construct(private Cache $cache) {}
+
+    public function shouldCache(TemplateContext $context): bool
+    {
+        return isset($context->metadata['fragment_id']);
+    }
+
+    public function generateKey(TemplateContext $context): string
+    {
+        $fragment = $context->metadata['fragment_id'] ?? 'default';
+        return "fragment:{$context->template}:{$fragment}:" . md5(serialize($context->data));
+    }
+
+    public function getTtl(TemplateContext $context): int
+    {
+        return 600; // 10 minutes - Fragments kürzer cachen
+    }
+
+    public function canInvalidate(string $template): bool
+    {
+        return true;
+    }
+}
diff --git a/src/Framework/View/Caching/Strategies/FullPageCacheStrategy.php b/src/Framework/View/Caching/Strategies/FullPageCacheStrategy.php
new file mode 100644
index 00000000..82617b09
--- /dev/null
+++ b/src/Framework/View/Caching/Strategies/FullPageCacheStrategy.php
@@ -0,0 +1,64 @@
+<?php
+
+namespace App\Framework\View\Caching\Strategies;
+
+use App\Framework\Cache\Cache;
+use App\Framework\View\Caching\TemplateContext;
+
+final readonly class FullPageCacheStrategy implements ViewCacheStrategy
+{
+    public function __construct(private Cache $cache) {}
+
+    public function shouldCache(TemplateContext $context): bool
+    {
+        // Keine User-spezifischen Daten
+        return !$this->hasUserData($context->data) &&
+            !$this->hasVolatileData($context->data);
+    }
+
+    public function generateKey(TemplateContext $context): string
+    {
+        return "page:{$context->template}:" . md5(serialize($this->getNonVolatileData($context->data)));
+    }
+
+    public function getTtl(TemplateContext $context): int
+    {
+        return match($this->getPageType($context->template)) {
+            'layout' => 3600,      // 1 hour
+            'static' => 7200,      // 2 hours
+            'content' => 1800,     // 30 minutes
+            default => 900         // 15 minutes
+        };
+    }
+
+    private function hasUserData(array $data): bool
+    {
+        $userKeys = ['user', 'auth', 'session', 'current_user'];
+        return !empty(array_intersect(array_keys($data), $userKeys));
+    }
+
+    private function hasVolatileData(array $data): bool
+    {
+        $volatileKeys = ['csrf_token', '_token', 'flash', 'errors', 'timestamp', 'now'];
+        return !empty(array_intersect(array_keys($data), $volatileKeys));
+    }
+
+    private function getNonVolatileData(array $data): array
+    {
+        $volatileKeys = ['csrf_token', '_token', 'flash', 'errors', 'timestamp', 'now', 'user', 'auth', 'session'];
+        return array_diff_key($data, array_flip($volatileKeys));
+    }
+
+    private function getPageType(string $template): string
+    {
+        if (str_contains($template, 'layout')) return 'layout';
+        if (str_contains($template, 'static')) return 'static';
+        if (str_contains($template, 'page')) return 'content';
+        return 'default';
+    }
+
+    public function canInvalidate(string $template): bool
+    {
+        return true;
+    }
+}
diff --git a/src/Framework/View/Caching/Strategies/NoCacheStrategy.php b/src/Framework/View/Caching/Strategies/NoCacheStrategy.php
new file mode 100644
index 00000000..284d8e63
--- /dev/null
+++ b/src/Framework/View/Caching/Strategies/NoCacheStrategy.php
@@ -0,0 +1,28 @@
+<?php
+
+namespace App\Framework\View\Caching\Strategies;
+
+use App\Framework\View\Caching\TemplateContext;
+
+final readonly class NoCacheStrategy implements ViewCacheStrategy
+{
+    public function shouldCache(TemplateContext $context): bool
+    {
+        return false;
+    }
+
+    public function generateKey(TemplateContext $context): string
+    {
+        return '';
+    }
+
+    public function getTtl(TemplateContext $context): int
+    {
+        return 0;
+    }
+
+    public function canInvalidate(string $template): bool
+    {
+        return false;
+    }
+}
diff --git a/src/Framework/View/Caching/Strategies/ViewCacheStrategy.php b/src/Framework/View/Caching/Strategies/ViewCacheStrategy.php
new file mode 100644
index 00000000..9cb8e253
--- /dev/null
+++ b/src/Framework/View/Caching/Strategies/ViewCacheStrategy.php
@@ -0,0 +1,13 @@
+<?php
+
+namespace App\Framework\View\Caching\Strategies;
+
+use App\Framework\View\Caching\TemplateContext;
+
+interface ViewCacheStrategy
+{
+    public function shouldCache(TemplateContext $context): bool;
+    public function generateKey(TemplateContext $context): string;
+    public function getTtl(TemplateContext $context): int;
+    public function canInvalidate(string $template): bool;
+}
diff --git a/src/Framework/View/Caching/TaggedFragmentCache.php b/src/Framework/View/Caching/TaggedFragmentCache.php
new file mode 100644
index 00000000..7d8f3fe9
--- /dev/null
+++ b/src/Framework/View/Caching/TaggedFragmentCache.php
@@ -0,0 +1,70 @@
+<?php
+
+namespace App\Framework\View\Caching;
+
+use App\Framework\Cache\Cache;
+
+class TaggedFragmentCache implements FragmentCache
+{
+    private array $tagMapping = [];
+
+    public function __construct(private Cache $cache) {}
+
+    public function fragment(string $key, callable $generator, int $ttl, array $tags = []): string
+    {
+        $fullKey = "fragment:{$key}";
+
+        $cached = $this->cache->get($fullKey);
+        if ($cached->isHit) {
+            return $cached->value;
+        }
+
+        $content = $generator();
+
+        $this->cache->set($fullKey, $content, $ttl);
+        $this->tagFragment($fullKey, $tags);
+
+        return $content;
+    }
+
+    public function invalidateFragment(string $key): bool
+    {
+        $fullKey = "fragment:{$key}";
+        return $this->cache->forget($fullKey);
+    }
+
+    public function invalidateByTags(array $tags): int
+    {
+        $invalidated = 0;
+        foreach ($tags as $tag) {
+            $keys = $this->getKeysByTag($tag);
+            foreach ($keys as $key) {
+                if ($this->cache->forget($key)) {
+                    $invalidated++;
+                }
+            }
+        }
+        return $invalidated;
+    }
+
+    public function hasFragment(string $key): bool
+    {
+        $fullKey = "fragment:{$key}";
+        return $this->cache->has($fullKey);
+    }
+
+    private function tagFragment(string $key, array $tags): void
+    {
+        foreach ($tags as $tag) {
+            if (!isset($this->tagMapping[$tag])) {
+                $this->tagMapping[$tag] = [];
+            }
+            $this->tagMapping[$tag][] = $key;
+        }
+    }
+
+    private function getKeysByTag(string $tag): array
+    {
+        return $this->tagMapping[$tag] ?? [];
+    }
+}
diff --git a/src/Framework/View/Caching/TemplateContext.php b/src/Framework/View/Caching/TemplateContext.php
new file mode 100644
index 00000000..ff057720
--- /dev/null
+++ b/src/Framework/View/Caching/TemplateContext.php
@@ -0,0 +1,13 @@
+<?php
+
+namespace App\Framework\View\Caching;
+
+class TemplateContext
+{
+    public function __construct(
+        public readonly string $template,
+        public readonly array $data,
+        public readonly ?string $controllerClass = null,
+        public readonly array $metadata = []
+    ) {}
+}
diff --git a/src/Framework/View/Compiler.php b/src/Framework/View/Compiler.php
deleted file mode 100644
index 798c4dfc..00000000
--- a/src/Framework/View/Compiler.php
+++ /dev/null
@@ -1,18 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace App\Framework\View;
-
-final readonly class Compiler
-{
-    public function compile(string $html): \DOMDocument
-    {
-        $dom = new \DOMDocument('1.0', 'UTF-8');
-        libxml_use_internal_errors(true);
-        $dom->loadHTML($html, LIBXML_HTML_NOIMPLIED | LIBXML_HTML_NODEFDTD);
-        libxml_clear_errors();
-
-        return $dom;
-    }
-}
diff --git a/src/Framework/View/ComponentCache.php b/src/Framework/View/ComponentCache.php
new file mode 100644
index 00000000..a1bc4be0
--- /dev/null
+++ b/src/Framework/View/ComponentCache.php
@@ -0,0 +1,40 @@
+<?php
+
+namespace App\Framework\View;
+
+use App\Framework\Filesystem\FileStorage;
+
+final readonly class ComponentCache
+{
+    public function __construct(
+        private string $cacheDir = __DIR__ . "/cache/components/",
+        private FileStorage $storage = new FileStorage,
+    ) {}
+
+    public function get(string $componentName, array $data, string $templatePath): ?string
+    {
+        $hash = $this->generateHash($templatePath, $data);
+        $cacheFile = $this->getCacheFile($componentName, $hash);
+
+        return $this->storage->exists($cacheFile) ? $this->storage->get($cacheFile) : null;
+    }
+
+    public function set(string $componentName, array $data, string $templatePath, string $output): void
+    {
+        $hash = $this->generateHash($templatePath, $data);
+        $cacheFile = $this->getCacheFile($componentName, $hash);
+
+        $this->storage->createDirectory($this->cacheDir);
+        $this->storage->put($cacheFile, $output);
+    }
+
+    private function generateHash(string $templatePath, array $data): string
+    {
+        return md5_file($templatePath) . '_' . md5(serialize($data));
+    }
+
+    private function getCacheFile(string $componentName, string $hash): string
+    {
+        return $this->cacheDir . "/{$componentName}_{$hash}.html";
+    }
+}
diff --git a/src/Framework/View/ComponentRenderer.php b/src/Framework/View/ComponentRenderer.php
index b05af4ca..424579b7 100644
--- a/src/Framework/View/ComponentRenderer.php
+++ b/src/Framework/View/ComponentRenderer.php
@@ -2,46 +2,38 @@
 
 namespace App\Framework\View;
 
-final class ComponentRenderer
+use App\Framework\Core\PathProvider;
+use App\Framework\Filesystem\FileStorage;
+use App\Framework\Meta\MetaData;
+use App\Framework\View\Loading\TemplateLoader;
+
+final readonly class ComponentRenderer
 {
     public function __construct(
-        private readonly TemplateLoader    $loader = new TemplateLoader(),
-        private readonly Compiler          $compiler = new Compiler(),
-        private readonly TemplateProcessor $processor = new TemplateProcessor(),
-        private string                     $cacheDir = __DIR__ . "/cache/components/"
+        private TemplateProcessor $processor,
+        private ComponentCache $cache,
+        private TemplateLoader    $loader,
+        private FileStorage       $storage = new FileStorage,
     ) {}
 
     public function render(string $componentName, array $data): string
     {
         $path = $this->loader->getComponentPath($componentName);
-        if (!file_exists($path)) {
+
+        if(!$this->storage->exists($path)) {
             return "<!-- Komponente '$componentName' nicht gefunden -->";
         }
 
-        # Cache prüfen
-        $hash = md5_file($path) . '_' . md5(serialize($data));
-        $cacheFile = $this->cacheDir . "/{$componentName}_{$hash}.html";;
-
-        if(file_exists($cacheFile)) {
-            return file_get_contents($cacheFile);
+        if(!$cached = $this->cache->get($componentName, $data, $path)) {
+            return $cached;
         }
 
+        $template = $this->storage->get($path);
+        $context = new RenderContext(template: $componentName, metaData: new MetaData(''), data: $data);
+        $output = $this->processor->render($context, $template);
 
-        $template = file_get_contents($path);
-        $compiled = $this->compiler->compile($template)->saveHTML();
+        $this->cache->set($componentName, $data, $path, $output);
 
-        $context = new RenderContext(
-            template: $componentName,
-            data: $data
-        );
-
-        $output = $this->processor->render($context, $compiled);
-
-        if(!is_dir($this->cacheDir)) {
-            mkdir($this->cacheDir, 0777, true);
-        }
-
-        file_put_contents($cacheFile, $output);
         return $output;
     }
 }
diff --git a/src/Framework/View/DOM/DomParser.php b/src/Framework/View/DOM/DomParser.php
deleted file mode 100644
index 1f02f1d7..00000000
--- a/src/Framework/View/DOM/DomParser.php
+++ /dev/null
@@ -1,48 +0,0 @@
-<?php
-
-namespace App\Framework\View\DOM;
-
-class DomParser
-{
-    public function domNodeToHTMLElement(\DOMNode $node, ?HTMLElement $parent = null): ?HTMLElement
-    {
-        switch ($node->nodeType) {
-            case XML_ELEMENT_NODE:
-                $attributes = [];
-                if ($node instanceof \DOMElement && $node->hasAttributes()) {
-                    foreach ($node->attributes as $attr) {
-                        $attributes[$attr->nodeName] = $attr->nodeValue;
-                    }
-                }
-
-                $el = new HTMLElement(
-                    tagName: $node->nodeName,
-                    attributes: $attributes,
-                    children: [],
-                    textContent: null,
-                    nodeType: 'element',
-                    namespace: $node->namespaceURI,
-                    parent: $parent
-                );
-
-                foreach ($node->childNodes as $child) {
-                    $childEl = $this->domNodeToHTMLElement($child, $el);
-                    if ($childEl) {
-                        $el->addChild($childEl);
-                    }
-                }
-
-                return $el;
-
-            case XML_TEXT_NODE:
-                return new HTMLElement(textContent: $node->nodeValue, nodeType: 'text');
-
-            case XML_COMMENT_NODE:
-                return new HTMLElement(textContent: $node->nodeValue, nodeType: 'comment');
-
-            default:
-                return null;
-        }
-    }
-
-}
diff --git a/src/Framework/View/DOM/HTMLElement.php b/src/Framework/View/DOM/HTMLElement.php
deleted file mode 100644
index 2ef92b6d..00000000
--- a/src/Framework/View/DOM/HTMLElement.php
+++ /dev/null
@@ -1,65 +0,0 @@
-<?php
-
-namespace App\Framework\View\DOM;
-
-class HTMLElement
-{
-    public function __construct(
-        public string $tagName = '',
-        public array $attributes = [],
-        public array $children = [],
-        public ?string $textContent = null,
-        public string $nodeType = 'element',  // 'element', 'text', 'comment'
-        public ?string $namespace = null,
-        public ?HTMLElement $parent = null
-    ) {}
-
-    public function attr(string $name, ?string $value = null): self|string|null
-    {
-        if ($value === null) {
-            return $this->attributes[$name] ?? null;
-        }
-
-        $this->attributes[$name] = $value;
-        return $this;
-    }
-
-    public function text(?string $value = null): self|string|null
-    {
-        if ($value === null) {
-            return $this->textContent;
-        }
-
-        $this->textContent = $value;
-        return $this;
-    }
-
-    public function addChild(HTMLElement $child): self
-    {
-        $child->parent = $this;
-        $this->children[] = $child;
-        return $this;
-    }
-
-    public function __toString(): string
-    {
-        if ($this->nodeType === 'text') {
-            return htmlspecialchars($this->textContent ?? '', ENT_QUOTES | ENT_SUBSTITUTE, 'UTF-8');
-        }
-
-        if ($this->nodeType === 'comment') {
-            return "<!-- " . $this->textContent . " -->";
-        }
-
-        $attrs = implode(' ', array_map(
-            fn($k, $v) => htmlspecialchars($k) . '="' . htmlspecialchars($v) . '"',
-            array_keys($this->attributes),
-            $this->attributes
-        ));
-
-        $content = implode('', array_map(fn($c) => (string)$c, $this->children));
-        $tag = htmlspecialchars($this->tagName);
-
-        return "<{$tag}" . ($attrs ? " $attrs" : "") . ">$content</{$tag}>";
-    }
-}
diff --git a/src/Framework/View/DOM/HtmlDocument.php b/src/Framework/View/DOM/HtmlDocument.php
deleted file mode 100644
index f63f1da8..00000000
--- a/src/Framework/View/DOM/HtmlDocument.php
+++ /dev/null
@@ -1,57 +0,0 @@
-<?php
-
-namespace App\Framework\View\DOM;
-
-final readonly class HtmlDocument
-{
-    private \DOMDocument $dom;
-
-    public function __construct(string $html = '')
-    {
-        $this->dom = new \DOMDocument('1.0', 'UTF-8');
-        if ($html !== '') {
-            libxml_use_internal_errors(true);
-            $success = $this->dom->loadHTML($html, LIBXML_HTML_NOIMPLIED | LIBXML_HTML_NODEFDTD);
-            if (!$success) {
-                throw new \RuntimeException("HTML Parsing failed.");
-            }
-            libxml_clear_errors();
-        }
-    }
-
-    public function querySelector(string $tagName): ?HtmlElement
-    {
-        $xpath = new \DOMXPath($this->dom);
-        $node = $xpath->query("//{$tagName}")->item(0);
-
-        return $node ? new DomParser()->domNodeToHTMLElement($node) : null;
-    }
-
-    public function querySelectorAll(string $tagName): NodeList
-    {
-        $xpath = new \DOMXPath($this->dom);
-        $nodes = $xpath->query("//{$tagName}");
-        $parser = new DomParser();
-
-        $elements = [];
-        foreach ($nodes as $node) {
-            $el = $parser->domNodeToHTMLElement($node);
-            if ($el) {
-                $elements[] = $el;
-            }
-        }
-
-        return new NodeList(...$elements);
-    }
-
-    public function toHtml(): string
-    {
-        return $this->dom->saveHTML() ?: '';
-    }
-
-    public function __toString(): string
-    {
-        return $this->toHtml();
-    }
-
-}
diff --git a/src/Framework/View/DOM/HtmlDocumentFormatter.php b/src/Framework/View/DOM/HtmlDocumentFormatter.php
deleted file mode 100644
index ed535bd3..00000000
--- a/src/Framework/View/DOM/HtmlDocumentFormatter.php
+++ /dev/null
@@ -1,55 +0,0 @@
-<?php
-
-namespace App\Framework\View\DOM;
-
-class HtmlDocumentFormatter
-{
-    private HtmlFormatter $formatter;
-    private DomParser $parser;
-
-    public function __construct(?HtmlFormatter $formatter = null)
-    {
-        $this->formatter = $formatter ?? new HtmlFormatter();
-        $this->parser = new DomParser();
-    }
-
-    /**
-     * Wandelt ein HTML-String in ein strukturiertes HTMLElement-Baumobjekt und formatiert es
-     */
-    public function formatHtmlString(string $html): string
-    {
-        $document = new \DOMDocument('1.0', 'UTF-8');
-        libxml_use_internal_errors(true);
-        $success = $document->loadHTML($html, LIBXML_HTML_NOIMPLIED | LIBXML_HTML_NODEFDTD);
-        if (!$success) {
-            throw new \RuntimeException("HTML Parsing failed.");
-        }
-        libxml_clear_errors();
-
-        $root = $document->documentElement;
-        if (!$root) {
-            return '';
-        }
-
-        $element = $this->parser->domNodeToHTMLElement($root);
-        return $this->formatter->format($element);
-    }
-
-    /**
-     * Formatiert ein HtmlDocument direkt
-     */
-    public function formatDocument(HtmlDocument $doc): string
-    {
-        $element = $doc->querySelector('html') ?? $doc->querySelector('body');
-        return $this->formatter->format($element);
-    }
-
-    /**
-     * Formatiert einen Teilbaum ab einem gegebenen HTMLElement
-     */
-    public function formatElement(HTMLElement $element): string
-    {
-        return $this->formatter->format($element);
-    }
-}
-}
diff --git a/src/Framework/View/DOM/HtmlFormatter.php b/src/Framework/View/DOM/HtmlFormatter.php
deleted file mode 100644
index 727d0942..00000000
--- a/src/Framework/View/DOM/HtmlFormatter.php
+++ /dev/null
@@ -1,53 +0,0 @@
-<?php
-
-namespace App\Framework\View\DOM;
-
-class HtmlFormatter
-{
-    private int $indentSize;
-    private string $indentChar;
-
-    public function __construct(int $indentSize = 2, string $indentChar = ' ')
-    {
-        $this->indentSize = $indentSize;
-        $this->indentChar = $indentChar;
-    }
-
-    public function format(HTMLElement $element, int $level = 0): string
-    {
-        $indent = str_repeat($this->indentChar, $level * $this->indentSize);
-
-        if ($element->nodeType === 'text') {
-            return $indent . htmlspecialchars($element->textContent ?? '', ENT_QUOTES | ENT_SUBSTITUTE, 'UTF-8') . "\n";
-        }
-
-        if ($element->nodeType === 'comment') {
-            return $indent . "<!-- " . $element->textContent . " -->\n";
-        }
-
-        $tag = htmlspecialchars($element->tagName);
-
-        $attrs = '';
-        foreach ($element->attributes as $key => $value) {
-            $attrs .= ' ' . htmlspecialchars($key) . '="' . htmlspecialchars($value) . '"';
-        }
-
-        if (empty($element->children) && empty($element->textContent)) {
-            return $indent . "<{$tag}{$attrs} />\n";
-        }
-
-        $output = $indent . "<{$tag}{$attrs}>\n";
-
-        foreach ($element->children as $child) {
-            $output .= $this->format($child, $level + 1);
-        }
-
-        if ($element->textContent !== null && $element->textContent !== '') {
-            $output .= str_repeat($this->indentChar, ($level + 1) * $this->indentSize);
-            $output .= htmlspecialchars($element->textContent, ENT_QUOTES | ENT_SUBSTITUTE, 'UTF-8') . "\n";
-        }
-
-        $output .= $indent . "</{$tag}>\n";
-        return $output;
-    }
-}
diff --git a/src/Framework/View/DOM/NodeList.php b/src/Framework/View/DOM/NodeList.php
deleted file mode 100644
index a9cede03..00000000
--- a/src/Framework/View/DOM/NodeList.php
+++ /dev/null
@@ -1,73 +0,0 @@
-<?php
-
-namespace App\Framework\View\DOM;
-
-class NodeList implements \IteratorAggregate, \Countable, \ArrayAccess
-{
-    /** @var HTMLElement[] */
-    private array $nodes = [];
-
-    public function __construct(HTMLElement ...$nodes)
-    {
-        $this->nodes = $nodes;
-    }
-
-    public function getIterator(): \ArrayIterator
-    {
-        return new \ArrayIterator($this->nodes);
-    }
-
-    public function count(): int
-    {
-        return count($this->nodes);
-    }
-
-    public function offsetExists($offset): bool
-    {
-        return isset($this->nodes[$offset]);
-    }
-
-    public function offsetGet($offset): mixed
-    {
-        return $this->nodes[$offset] ?? null;
-    }
-
-    public function offsetSet($offset, $value): void
-    {
-        if (!$value instanceof HTMLElement) {
-            throw new \InvalidArgumentException("Only HTMLElement instances allowed.");
-        }
-
-        if ($offset === null) {
-            $this->nodes[] = $value;
-        } else {
-            $this->nodes[$offset] = $value;
-        }
-    }
-
-    public function offsetUnset($offset): void
-    {
-        unset($this->nodes[$offset]);
-    }
-
-    // Beispiel für Hilfsmethoden:
-    public function first(): ?HTMLElement
-    {
-        return $this->nodes[0] ?? null;
-    }
-
-    public function filter(callable $fn): self
-    {
-        return new self(...array_filter($this->nodes, $fn));
-    }
-
-    public function map(callable $fn): array
-    {
-        return array_map($fn, $this->nodes);
-    }
-
-    public function toArray(): array
-    {
-        return $this->nodes;
-    }
-}
diff --git a/src/Framework/View/DomComponentService.php b/src/Framework/View/DomComponentService.php
new file mode 100644
index 00000000..7c030fc0
--- /dev/null
+++ b/src/Framework/View/DomComponentService.php
@@ -0,0 +1,34 @@
+<?php
+
+namespace App\Framework\View;
+
+use Dom\Element;
+
+final readonly class DomComponentService
+{
+    public function replaceComponent(DomWrapper $dom, Element $component, string $html): void {
+        $dom->replaceElementWithHtml($component, $html);
+    }
+
+    public function processSlots(DomWrapper $dom): void {
+        $slots = $dom->getElementsByTagName('slot');
+
+        $slots->forEach(function($slot) use ($dom) {
+            $name = $slot->getAttribute('name') ?? 'default';
+            $content = $this->getSlotContent($dom, $name);
+
+            if ($content) {
+                $dom->replaceElementWithHtml($slot, $content);
+            }
+        });
+    }
+
+    private function getSlotContent(DomWrapper $dom, string $name): ?string {
+        $slotProviders = $dom->getElementsByAttribute('slot', $name);
+        if ($slotProviders->isEmpty()) {
+            return null;
+        }
+
+        return $slotProviders->first()->innerHTML;
+    }
+}
diff --git a/src/Framework/View/DomFormService.php b/src/Framework/View/DomFormService.php
new file mode 100644
index 00000000..b8602627
--- /dev/null
+++ b/src/Framework/View/DomFormService.php
@@ -0,0 +1,43 @@
+<?php
+
+namespace App\Framework\View;
+
+use Dom\Element;
+
+final readonly class DomFormService
+{
+    public function addCsrfTokenToForms(DomWrapper $dom, string $token): void {
+        $forms = $dom->getElementsByTagName('form');
+
+        $forms->forEach(function($form) use ($dom, $token) {
+            $this->addCsrfTokenToForm($dom, $form, $token);
+        });
+    }
+
+    public function addCsrfTokenToForm(DomWrapper $dom, Element $form, string $token): void {
+        // Prüfen ob bereits vorhanden
+        $existing = $form->querySelector('input[name="_token"]');
+        if ($existing) {
+            $existing->setAttribute('value', $token);
+            return;
+        }
+
+        $csrf = $dom->document->createElement('input');
+        $csrf->setAttribute('type', 'hidden');
+        $csrf->setAttribute('name', '_token');
+        $csrf->setAttribute('value', $token);
+
+        $form->insertBefore($csrf, $form->firstChild);
+    }
+
+    public function addHoneypotField(DomWrapper $dom, Element $form, string $fieldName = 'email_confirm'): void {
+        $honeypot = $dom->document->createElement('input');
+        $honeypot->setAttribute('type', 'text');
+        $honeypot->setAttribute('name', $fieldName);
+        $honeypot->setAttribute('style', 'display:none;position:absolute;left:-9999px;');
+        $honeypot->setAttribute('tabindex', '-1');
+        $honeypot->setAttribute('autocomplete', 'off');
+
+        $form->insertBefore($honeypot, $form->firstChild);
+    }
+}
diff --git a/src/Framework/View/DomHeadService.php b/src/Framework/View/DomHeadService.php
new file mode 100644
index 00000000..7120c905
--- /dev/null
+++ b/src/Framework/View/DomHeadService.php
@@ -0,0 +1,57 @@
+<?php
+
+namespace App\Framework\View;
+
+final readonly class DomHeadService
+{
+    public function appendToHead(DomWrapper $dom, string $html): void {
+        $head = $dom->getElementsByTagName('head')->first();
+        if (!$head) {
+            // Fallback: head erstellen oder zu body hinzufügen
+            $head = $dom->document->createElement('head');
+            $dom->document->documentElement->insertBefore($head, $dom->document->body);
+        }
+
+        $fragment = $dom->createFragmentFromHtml($html);
+        $head->appendChild($fragment);
+    }
+
+    public function prependToHead(DomWrapper $dom, string $html): void {
+        $head = $dom->getElementsByTagName('head')->first();
+        if (!$head) return;
+
+        $fragment = $dom->createFragmentFromHtml($html);
+        $head->insertBefore($fragment, $head->firstChild);
+    }
+
+    public function addStylesheet(DomWrapper $dom, string $href): void {
+        $link = $dom->document->createElement('link');
+        $link->setAttribute('rel', 'stylesheet');
+        $link->setAttribute('href', $href);
+
+        $head = $dom->getElementsByTagName('head')->first();
+        $head?->appendChild($link);
+    }
+
+    public function addScript(DomWrapper $dom, string $src, array $attributes = []): void {
+        $script = $dom->document->createElement('script');
+        $script->setAttribute('src', $src);
+        $script->setAttribute('type', 'module');
+
+        foreach ($attributes as $name => $value) {
+            $script->setAttribute($name, $value);
+        }
+
+        $head = $dom->getElementsByTagName('head')->first();
+        $head?->appendChild($script);
+    }
+
+    public function addMeta(DomWrapper $dom, string $name, string $content): void {
+        $meta = $dom->document->createElement('meta');
+        $meta->setAttribute('name', $name);
+        $meta->setAttribute('content', $content);
+
+        $head = $dom->getElementsByTagName('head')->first();
+        $head?->appendChild($meta);
+    }
+}
diff --git a/src/Framework/View/DomProcessor.php b/src/Framework/View/DomProcessor.php
index 9c1fb0c8..9ae20f14 100644
--- a/src/Framework/View/DomProcessor.php
+++ b/src/Framework/View/DomProcessor.php
@@ -2,15 +2,9 @@
 
 namespace App\Framework\View;
 
+use Dom\HTMLDocument;
+
 interface DomProcessor
 {
-    /**
-     * Manipuliert das gegebene DOM.
-     * @param \DOMDocument $dom
-     * @param array $data
-     * @param callable|null $componentRenderer Optional, kann z.B. für Komponenten übergeben werden
-     */
-    ##public function process(\DOMDocument $dom, array $data, ?callable $componentRenderer = null): void;
-
-    public function process(\DOMDocument $dom, RenderContext $context): void;
+    public function process(DomWrapper $dom, RenderContext $context): DomWrapper;
 }
diff --git a/src/Framework/View/DomTemplateParser.php b/src/Framework/View/DomTemplateParser.php
index 3c7e6c66..40312371 100644
--- a/src/Framework/View/DomTemplateParser.php
+++ b/src/Framework/View/DomTemplateParser.php
@@ -2,30 +2,48 @@
 
 namespace App\Framework\View;
 
+use Dom\HTMLDocument;
 use DOMDocument;
 
 final class DomTemplateParser
 {
-    public function parse(string $html): DOMDocument
+    public function parse(string $html): HTMLDocument
     {
+        //$html = preg_replace('#<(img|br|hr|input|meta|link|area|base|col|embed|source|track|wbr)([^>]*)>#i', '<$1$2 />', $html);
+
+
         libxml_use_internal_errors(true);
 
-        $dom = new DOMDocument('1.0', 'UTF-8');
-        $dom->preserveWhiteSpace = false;
-        $dom->formatOutput = true;
-
-        $dom->loadHTML(
-            $html,
-            LIBXML_HTML_NOIMPLIED | LIBXML_HTML_NODEFDTD
-        );
+        $dom = HTMLDocument::createFromString($html);
 
         libxml_clear_errors();
 
         return $dom;
     }
 
-    public function toHtml(DOMDocument $dom): string
+    /**
+     * Erstellt einen DomWrapper aus HTML-String
+     */
+    public function parseToWrapper(string $html): DomWrapper
+    {
+        return DomWrapper::fromString($html);
+    }
+
+    /**
+     * Erstellt einen DomWrapper aus Datei
+     */
+    public function parseFileToWrapper(string $path): DomWrapper
+    {
+        return DomWrapper::fromFile($path);
+    }
+
+    public function toHtml(HTMLDocument $dom): string
     {
         return $dom->saveHTML();
     }
+
+    public function parseFile(string $path): HTMLDocument
+    {
+        return HTMLDocument::createFromFile($path);
+    }
 }
diff --git a/src/Framework/View/DomWrapper.php b/src/Framework/View/DomWrapper.php
new file mode 100644
index 00000000..199b4cb4
--- /dev/null
+++ b/src/Framework/View/DomWrapper.php
@@ -0,0 +1,261 @@
+<?php
+
+namespace App\Framework\View;
+
+use Dom\HTMLDocument;
+use Dom\Element;
+use Dom\HTMLElement;
+use Dom\Node;
+use Dom\DocumentFragment;
+
+/**
+ * Wrapper-Klasse für HTMLDocument mit erweiterten Template-spezifischen Operationen
+ */
+final readonly class DomWrapper
+{
+    public function __construct(
+        public HTMLDocument $document
+    ) {}
+
+    /**
+     * Erstellt einen DomWrapper aus HTML-String
+     */
+    public static function fromString(string $html): self
+    {
+        libxml_use_internal_errors(true);
+        $dom = HTMLDocument::createFromString($html);
+        libxml_clear_errors();
+
+        return new self($dom);
+    }
+
+    /**
+     * Erstellt einen DomWrapper aus Datei
+     */
+    public static function fromFile(string $path): self
+    {
+        $dom = HTMLDocument::createFromFile($path);
+        return new self($dom);
+    }
+
+    /**
+     * Konvertiert zu HTML-String
+     */
+    public function toHtml(bool $bodyOnly = false): string
+    {
+        if ($bodyOnly && $this->document->body) {
+            return $this->document->body->innerHTML;
+        }
+
+        return $this->document->saveHTML();
+    }
+
+    /**
+     * Findet Elemente nach Tag-Name
+     */
+    public function getElementsByTagName(string $tagName): ElementCollection
+    {
+        $elements = iterator_to_array($this->document->getElementsByTagName($tagName));
+        return new ElementCollection($elements, $this);
+    }
+
+    /**
+     * Findet Element nach ID
+     */
+    public function getElementById(string $id): ?Element
+    {
+        return $this->document->getElementById($id);
+    }
+
+    /**
+     * Findet Elemente nach Name-Attribut
+     */
+    public function getElementsByName(string $name): ElementCollection
+    {
+        $elements = [];
+        $this->findElementsByNameRecursive($this->document->documentElement, $name, $elements);
+        return new ElementCollection($elements, $this);
+    }
+
+    private function findElementsByNameRecursive(?Node $node, string $name, array &$elements): void
+    {
+        if (!$node || $node->nodeType !== XML_ELEMENT_NODE) {
+            return;
+        }
+
+        if ($node instanceof Element && $node->getAttribute('name') === $name) {
+            $elements[] = $node;
+        }
+
+        foreach ($node->childNodes as $child) {
+            $this->findElementsByNameRecursive($child, $name, $elements);
+        }
+    }
+
+    /**
+     * Findet Elemente nach Attribut und Wert
+     */
+    public function getElementsByAttribute(string $attribute, ?string $value = null): ElementCollection
+    {
+        $elements = [];
+        $this->findElementsByAttributeRecursive($this->document->documentElement, $attribute, $value, $elements);
+        return new ElementCollection($elements, $this);
+    }
+
+    private function findElementsByAttributeRecursive(?Node $node, string $attribute, ?string $value, array &$elements): void
+    {
+        if (!$node || $node->nodeType !== XML_ELEMENT_NODE) {
+            return;
+        }
+
+        if ($node instanceof Element) {
+            if ($value === null && $node->hasAttribute($attribute)) {
+                $elements[] = $node;
+            } elseif ($value !== null && $node->getAttribute($attribute) === $value) {
+                $elements[] = $node;
+            }
+        }
+
+        foreach ($node->childNodes as $child) {
+            $this->findElementsByAttributeRecursive($child, $attribute, $value, $elements);
+        }
+    }
+
+    /**
+     * Erstellt ein Document Fragment
+     */
+    public function createFragment(): DocumentFragment
+    {
+        return $this->document->createDocumentFragment();
+    }
+
+    /**
+     * Erstellt ein Fragment aus HTML-String
+     */
+    public function createFragmentFromHtml(string $html): DocumentFragment
+    {
+        $fragment = $this->document->createDocumentFragment();
+        $fragment->appendXML($html);
+        return $fragment;
+    }
+
+    /**
+     * Ersetzt ein Element durch HTML-Content
+     */
+    public function replaceElementWithHtml(Element $element, string $html): void
+    {
+        $fragment = $this->createFragmentFromHtml($html);
+        $element->parentNode?->replaceChild($fragment, $element);
+    }
+
+    /**
+     * Entfernt leere Textknoten
+     */
+    public function removeEmptyTextNodes(): self
+    {
+        $this->removeEmptyTextNodesRecursive($this->document->documentElement);
+        return $this;
+    }
+
+    private function removeEmptyTextNodesRecursive(?Node $node): void
+    {
+        if (!$node) {
+            return;
+        }
+
+        $childNodes = [];
+        foreach ($node->childNodes as $child) {
+            $childNodes[] = $child;
+        }
+
+        foreach ($childNodes as $child) {
+            if ($child->nodeType === XML_TEXT_NODE && trim($child->textContent) === '') {
+                $node->removeChild($child);
+            } else {
+                $this->removeEmptyTextNodesRecursive($child);
+            }
+        }
+    }
+
+    /**
+     * Fügt CSS-Klasse zu einem Element hinzu
+     */
+    public function addClass(Element $element, string $className): void
+    {
+        $currentClass = $element->getAttribute('class');
+        $classes = $currentClass ? explode(' ', $currentClass) : [];
+
+        if (!in_array($className, $classes)) {
+            $classes[] = $className;
+            $element->setAttribute('class', implode(' ', $classes));
+        }
+    }
+
+    /**
+     * Entfernt CSS-Klasse von einem Element
+     */
+    public function removeClass(Element $element, string $className): void
+    {
+        $currentClass = $element->getAttribute('class');
+        if (!$currentClass) {
+            return;
+        }
+
+        $classes = array_filter(explode(' ', $currentClass), fn($c) => $c !== $className);
+        $element->setAttribute('class', implode(' ', $classes));
+    }
+
+    /**
+     * Prüft ob Element eine CSS-Klasse hat
+     */
+    public function hasClass(Element $element, string $className): bool
+    {
+        $currentClass = $element->getAttribute('class');
+        if (!$currentClass) {
+            return false;
+        }
+
+        return in_array($className, explode(' ', $currentClass));
+    }
+
+    /**
+     * Findet Elemente nach CSS-Klasse
+     */
+    public function getElementsByClassName(string $className): ElementCollection
+    {
+        $elements = [];
+        $this->findElementsByClassRecursive($this->document->documentElement, $className, $elements);
+        return new ElementCollection($elements, $this);
+    }
+
+    private function findElementsByClassRecursive(?Node $node, string $className, array &$elements): void
+    {
+        if (!$node || $node->nodeType !== XML_ELEMENT_NODE) {
+            return;
+        }
+
+        if ($node instanceof Element && $this->hasClass($node, $className)) {
+            $elements[] = $node;
+        }
+
+        foreach ($node->childNodes as $child) {
+            $this->findElementsByClassRecursive($child, $className, $elements);
+        }
+    }
+
+    /**
+     * Setzt Attribut für ein Element
+     */
+    public function setAttribute(Element $element, string $name, string $value): void
+    {
+        $element->setAttribute($name, $value);
+    }
+
+    /**
+     * Entfernt Attribut von einem Element
+     */
+    public function removeAttribute(Element $element, string $name): void
+    {
+        $element->removeAttribute($name);
+    }
+}
diff --git a/src/Framework/View/ElementCollection.php b/src/Framework/View/ElementCollection.php
new file mode 100644
index 00000000..90612fde
--- /dev/null
+++ b/src/Framework/View/ElementCollection.php
@@ -0,0 +1,279 @@
+<?php
+
+namespace App\Framework\View;
+
+use ArrayIterator;
+use Countable;
+use Dom\Element;
+use IteratorAggregate;
+
+/**
+ * Funktionale Sammlung für DOM-Elemente mit moderner API
+ */
+final class ElementCollection implements IteratorAggregate, Countable
+{
+    public function __construct(
+        private array $elements,
+        private DomWrapper $wrapper
+    ) {}
+
+    /**
+     * Führt eine Funktion für jedes Element aus
+     */
+    public function forEach(callable $callback): self
+    {
+        foreach ($this->elements as $index => $element) {
+            $callback($element, $index);
+        }
+        return $this;
+    }
+
+    /**
+     * Transformiert jedes Element und gibt ein Array zurück
+     */
+    public function map(callable $callback): array
+    {
+        return array_map($callback, $this->elements);
+    }
+
+    /**
+     * Filtert Elemente basierend auf einer Bedingung
+     */
+    public function filter(callable $callback): self
+    {
+        return new self(
+            array_values(array_filter($this->elements, $callback)),
+            $this->wrapper
+        );
+    }
+
+    /**
+     * Reduziert die Sammlung zu einem einzelnen Wert
+     */
+    public function reduce(callable $callback, mixed $initial = null): mixed
+    {
+        return array_reduce($this->elements, $callback, $initial);
+    }
+
+    /**
+     * Prüft ob mindestens ein Element die Bedingung erfüllt
+     */
+    public function some(callable $callback): bool
+    {
+        foreach ($this->elements as $element) {
+            if ($callback($element)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /**
+     * Prüft ob alle Elemente die Bedingung erfüllen
+     */
+    public function every(callable $callback): bool
+    {
+        foreach ($this->elements as $element) {
+            if (!$callback($element)) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    /**
+     * Findet das erste Element, das die Bedingung erfüllt
+     */
+    public function find(callable $callback): ?Element
+    {
+        foreach ($this->elements as $element) {
+            if ($callback($element)) {
+                return $element;
+            }
+        }
+        return null;
+    }
+
+    /**
+     * Gibt das erste Element zurück
+     */
+    public function first(): ?Element
+    {
+        return $this->elements[0] ?? null;
+    }
+
+    /**
+     * Gibt das letzte Element zurück
+     */
+    public function last(): ?Element
+    {
+        return end($this->elements) ?: null;
+    }
+
+    /**
+     * Gibt das Element an der angegebenen Position zurück
+     */
+    public function at(int $index): ?Element
+    {
+        return $this->elements[$index] ?? null;
+    }
+
+    /**
+     * Nimmt die ersten n Elemente
+     */
+    public function take(int $count): self
+    {
+        return new self(
+            array_slice($this->elements, 0, $count),
+            $this->wrapper
+        );
+    }
+
+    /**
+     * Überspringt die ersten n Elemente
+     */
+    public function skip(int $count): self
+    {
+        return new self(
+            array_slice($this->elements, $count),
+            $this->wrapper
+        );
+    }
+
+    /**
+     * Fügt CSS-Klasse zu allen Elementen hinzu
+     */
+    public function addClass(string $className): self
+    {
+        return $this->forEach(fn($el) => $this->wrapper->addClass($el, $className));
+    }
+
+    /**
+     * Entfernt CSS-Klasse von allen Elementen
+     */
+    public function removeClass(string $className): self
+    {
+        return $this->forEach(fn($el) => $this->wrapper->removeClass($el, $className));
+    }
+
+    /**
+     * Setzt Attribut für alle Elemente
+     */
+    public function setAttribute(string $name, string $value): self
+    {
+        return $this->forEach(fn($el) => $el->setAttribute($name, $value));
+    }
+
+    /**
+     * Entfernt Attribut von allen Elementen
+     */
+    public function removeAttribute(string $name): self
+    {
+        return $this->forEach(fn($el) => $el->removeAttribute($name));
+    }
+
+    /**
+     * Setzt innerHTML für alle Elemente
+     */
+    public function setInnerHTML(string $html): self
+    {
+        return $this->forEach(fn($el) => $el->innerHTML = $html);
+    }
+
+    /**
+     * Setzt textContent für alle Elemente
+     */
+    public function setTextContent(string $text): self
+    {
+        return $this->forEach(fn($el) => $el->textContent = $text);
+    }
+
+    /**
+     * Ersetzt alle Elemente mit HTML-Content
+     */
+    public function replaceWith(string $html): void
+    {
+        $this->forEach(fn($el) => $this->wrapper->replaceElementWithHtml($el, $html));
+    }
+
+    /**
+     * Entfernt alle Elemente aus dem DOM
+     */
+    public function remove(): void
+    {
+        $this->forEach(fn($el) => $el->parentNode?->removeChild($el));
+    }
+
+    /**
+     * Kombiniert diese Sammlung mit einer anderen
+     */
+    public function merge(ElementCollection $other): self
+    {
+        return new self(
+            array_merge($this->elements, $other->elements),
+            $this->wrapper
+        );
+    }
+
+    /**
+     * Gibt eindeutige Elemente zurück
+     */
+    public function unique(): self
+    {
+        return new self(
+            array_values(array_unique($this->elements, SORT_REGULAR)),
+            $this->wrapper
+        );
+    }
+
+    /**
+     * Prüft ob die Sammlung leer ist
+     */
+    public function isEmpty(): bool
+    {
+        return empty($this->elements);
+    }
+
+    /**
+     * Prüft ob die Sammlung nicht leer ist
+     */
+    public function isNotEmpty(): bool
+    {
+        return !$this->isEmpty();
+    }
+
+    /**
+     * Konvertiert zu Array
+     */
+    public function toArray(): array
+    {
+        return $this->elements;
+    }
+
+    /**
+     * Gibt die Anzahl der Elemente zurück
+     */
+    public function count(): int
+    {
+        return count($this->elements);
+    }
+
+    /**
+     * Iterator für foreach-Schleifen
+     */
+    public function getIterator(): ArrayIterator
+    {
+        return new ArrayIterator($this->elements);
+    }
+
+    /**
+     * Debug-Information
+     */
+    public function __debugInfo(): array
+    {
+        return [
+            'count' => $this->count(),
+            'elements' => $this->elements
+        ];
+    }
+}
diff --git a/src/Framework/View/Engine.php b/src/Framework/View/Engine.php
index aa19710d..4f612aaf 100644
--- a/src/Framework/View/Engine.php
+++ b/src/Framework/View/Engine.php
@@ -1,53 +1,162 @@
 <?php
-
 declare(strict_types=1);
 
 namespace App\Framework\View;
 
-use App\Framework\View\Processors\ComponentProcessor;
-use App\Framework\View\Processors\LayoutTagProcessor;
-use App\Framework\View\Processors\PlaceholderReplacer;
+use App\Framework\Attributes\Singleton;
+use App\Framework\Cache\Cache;
+use App\Framework\Core\PathProvider;
+use App\Framework\DI\Container;
+use App\Framework\DI\DefaultContainer;
+use App\Framework\Filesystem\FileStorage;
+use App\Framework\View\Caching\Analysis\SmartTemplateAnalyzer;
+use App\Framework\View\Caching\CacheManager;
+use App\Framework\View\Caching\TaggedFragmentCache;
+use App\Framework\View\Caching\TemplateContext;
+use App\Framework\View\Loading\TemplateLoader;
+use App\Framework\View\Processors\CsrfReplaceProcessor;
+use Archive\Optimized\QuickSmartCacheReplacement;
 
+#[Singleton]
 final readonly class Engine implements TemplateRenderer
 {
+    private ?TemplateRenderer $smartCache;
+
+    private ?CacheManager $cacheManager;
+
     public function __construct(
-        private TemplateLoader $loader = new TemplateLoader(),
-        private Compiler       $compiler = new Compiler(),
-        private Renderer       $renderer = new Renderer(),
-        private TemplateProcessor $processor = new TemplateProcessor()
+        private TemplateLoader    $loader,
+        private PathProvider         $pathProvider,
+        private DomTemplateParser $parser = new DomTemplateParser,
+        private TemplateProcessor $processor = new TemplateProcessor,
+        private FileStorage       $storage = new FileStorage,
+        private string            $cachePath = __DIR__ . "/cache",
+        private Container        $container = new DefaultContainer(),
+        private bool             $useSmartCache = true,
+        private bool             $legacyCacheEnabled = false,
+        ?Cache                   $cache = null,
+        private bool             $cacheEnabled = true,
     ) {
-        $this->processor->registerDom(new ComponentProcessor());
-        $this->processor->registerDom(new LayoutTagProcessor());
-        $this->processor->registerDom(new PlaceholderReplacer());
+        // Stelle sicher, dass das Cache-Verzeichnis existiert
+        if (!is_dir($this->cachePath)) {
+            mkdir($this->cachePath, 0755, true);
+        }
+/*
+        // Initialisiere Smart Cache System
+        if ($this->useSmartCache && $cache) {
+            #$analyzer = new TemplateAnalyzer();
+            #$fragmentCache = new FragmentCacheManager($cache);
+
+            $this->smartCache = new QuickSmartCacheReplacement(
+                cache: $cache,
+                #analyzer     : $analyzer,
+                #fragmentCache: $fragmentCache,
+                loader: $this->loader,
+                processor: $this->processor
+            );
+        } else {
+            $this->smartCache = null;
+        }*/
+
+        // Neues Cache-System initialisieren
+        if ($this->cacheEnabled && $cache) {
+            $analyzer = new SmartTemplateAnalyzer($this->loader);
+            $fragmentCache = new TaggedFragmentCache($cache);
+
+            $this->cacheManager = new CacheManager(
+                cache: $cache,
+                analyzer: $analyzer,
+                fragmentCache: $fragmentCache
+            );
+        } else {
+            $this->cacheManager = null;
+        }
     }
 
     public function render(RenderContext $context): string
     {
+        // Verwende neuen CacheManager wenn verfügbar
+        if ($this->cacheManager) {
+            $templateContext = new TemplateContext(
+                template: $context->template,
+                data: $context->data,
+                controllerClass: $context->controllerClass,
+                metadata: $context->metaData ? ['meta' => $context->metaData] : []
+            );
 
-        $template = $context->template;
-        $data   = $context->data;
+            return $this->cacheManager->render($templateContext, function() use ($context) {
+                return $this->renderDirect($context);
+            });
+        }
 
-        $cacheFile = __DIR__ . "/cache/{$template}.cache.html";
+        // Fallback ohne Cache
+        return $this->renderDirect($context);
 
-        $templateFile = $this->loader->getTemplatePath($template); // Neue Methode in TemplateLoader
 
-        // Prüfen ob Cache existiert und nicht älter als das Template
-        if (file_exists($cacheFile) && filemtime($cacheFile) >= filemtime($templateFile)) {
-            $content = file_get_contents($cacheFile);
-            #$dom = $this->compiler->compile($content);
-        } else {
-            // Template normal laden und kompilieren
-            $content = $this->loader->load($template, $context->controllerClass);;
-            $content = "<test>{$content}</test>";
-            $dom = $this->compiler->compile($content);
-            $html = $dom->saveHTML();
-            // (Optional) VOR dynamischer Verarbeitung rohe Struktur cachen
-            file_put_contents($cacheFile, $dom->saveHTML());
-            $content = $html;
+        // Verwende Smart Cache wenn verfügbar
+        if ($this->useSmartCache && $this->smartCache !== null) {
+
+            $processor = new TemplateProcessor([],[CsrfReplaceProcessor::class], $this->container);
+
+            $cachedOutput = $this->smartCache->render($context);
+            return $processor->render($context, $cachedOutput ?? '');
         }
 
 
-        return $this->processor->render($context, $content);
-        #return $this->renderer->render($dom, $data, $this);
+        // Fallback zu Legacy-Caching oder direkt rendern
+        return $this->legacyCacheEnabled
+            ? $this->renderWithLegacyCache($context)
+            : $this->renderDirect($context);
     }
+
+    private function renderWithLegacyCache(RenderContext $context): string
+    {
+        $cacheKey = 'view_' . md5($context->template . '_' . ($context->controllerClass ?? ''));
+        $templateFile = $this->loader->getTemplatePath($context->template, $context->controllerClass);
+        $cacheFile = $this->cachePath . "/{$cacheKey}.cache.html";
+
+        // Prüfe ob Cache existiert und nicht älter als das Template
+        // FIXED: Entferne das "x" Suffix um Caching zu reaktivieren
+        if (file_exists($cacheFile) && filemtime($cacheFile) >= filemtime($templateFile)) {
+            $content = $this->storage->get($cacheFile);
+        } else {
+            // Template normal laden und kompilieren
+            $content = $this->loader->load($context->template, $context->controllerClass, $context);
+            $dom = $this->parser->parse($content);
+            $html = $dom->saveHTML();
+
+            $html = html_entity_decode($html);
+            // VOR dynamischer Verarbeitung rohe Struktur cachen
+            $this->storage->put($cacheFile, $html);
+            $content = $html;
+        }
+
+        return $this->processor->render($context, $content);
+    }
+
+    private function renderDirect(RenderContext $context): string
+    {
+        $content = $this->loader->load($context->template, $context->controllerClass, $context);
+        $dom = $this->parser->parse($content);
+        $html = html_entity_decode($dom->saveHTML());
+        return $this->processor->render($context, $html);
+    }
+
+    public function invalidateCache(?string $template = null): int
+    {
+        return $this->cacheManager?->invalidateTemplate($template) ?? 0;
+    }
+
+    public function getCacheStats(): array
+    {
+        if (!$this->cacheManager) {
+            return ['cache_enabled' => false];
+        }
+
+        return [
+            'cache_enabled' => true,
+            'cache_manager' => $this->cacheManager->getStats(), // Diese Methode müsstest du noch implementieren
+        ];
+    }
+
 }
diff --git a/src/Framework/View/EnhancedDomProcessor.php b/src/Framework/View/EnhancedDomProcessor.php
new file mode 100644
index 00000000..c3e67eb9
--- /dev/null
+++ b/src/Framework/View/EnhancedDomProcessor.php
@@ -0,0 +1,19 @@
+<?php
+
+namespace App\Framework\View;
+
+use Dom\HTMLDocument;
+
+/**
+ * Erweiterte Version des DomProcessor-Interfaces mit DomWrapper-Unterstützung
+ */
+interface EnhancedDomProcessor extends DomProcessor
+{
+    /**
+     * Verarbeitet das DOM mit dem erweiterten DomWrapper
+     * @param DomWrapper $dom Zu manipulierender DOM-Wrapper
+     * @param RenderContext $context Kontext für die Verarbeitung
+     * @return DomWrapper Der veränderte DOM-Wrapper
+     */
+    public function process(DomWrapper $dom, RenderContext $context): DomWrapper;
+}
diff --git a/src/Framework/View/EnhancedTemplateProcessor.php b/src/Framework/View/EnhancedTemplateProcessor.php
new file mode 100644
index 00000000..7d5ebe17
--- /dev/null
+++ b/src/Framework/View/EnhancedTemplateProcessor.php
@@ -0,0 +1,78 @@
+<?php
+
+namespace App\Framework\View;
+
+use App\Framework\DI\Container;
+
+/**
+ * Erweiterte Version des TemplateProcessors mit DomWrapper-Unterstützung
+ */
+final readonly class EnhancedTemplateProcessor
+{
+    public function __construct(
+        private array $domProcessors,
+        private array $stringProcessors,
+        private Container $container
+    ) {}
+
+    public function render(RenderContext $context, string $html, bool $component = false): string
+    {
+        $parser = new DomTemplateParser();
+        $domWrapper = $parser->parseToWrapper($html);
+
+        // Verkettete Verarbeitung der DOM-Prozessoren
+        foreach ($this->domProcessors as $processorClass) {
+            $processor = $this->container->get($processorClass);
+
+            if ($processor instanceof EnhancedDomProcessor) {
+                // Verwende die erweiterte DomWrapper-Funktionalität
+                $domWrapper = $processor->processWrapper($domWrapper, $context);
+            } else {
+                // Fallback für bestehende Prozessoren
+                $dom = $processor->process($domWrapper->document, $context);
+                $domWrapper = new DomWrapper($dom);
+            }
+        }
+
+        $html = $domWrapper->toHtml($component);
+
+        // Verarbeitung durch String-Prozessoren
+        foreach ($this->stringProcessors as $processorClass) {
+            $processor = $this->container->get($processorClass);
+            $html = $processor->process($html, $context);
+        }
+
+        return $html;
+    }
+
+    /**
+     * Rendert direkt mit DomWrapper für erweiterte Kontrolle
+     */
+    public function renderWithWrapper(RenderContext $context, string $html, bool $component = false): DomWrapper
+    {
+        $parser = new DomTemplateParser();
+        $domWrapper = $parser->parseToWrapper($html);
+
+        // Verkettete Verarbeitung der DOM-Prozessoren
+        foreach ($this->domProcessors as $processorClass) {
+            $processor = $this->container->get($processorClass);
+
+            if ($processor instanceof EnhancedDomProcessor) {
+                $domWrapper = $processor->processWrapper($domWrapper, $context);
+            } else {
+                $dom = $processor->process($domWrapper->document, $context);
+                $domWrapper = new DomWrapper($dom);
+            }
+        }
+
+        return $domWrapper;
+    }
+
+    public function __debugInfo(): ?array
+    {
+        return [
+            'domProcessors' => $this->domProcessors,
+            'stringProcessors' => $this->stringProcessors,
+        ];
+    }
+}
diff --git a/src/Framework/View/Exception/TemplateNotFound.php b/src/Framework/View/Exception/TemplateNotFound.php
new file mode 100644
index 00000000..946cb360
--- /dev/null
+++ b/src/Framework/View/Exception/TemplateNotFound.php
@@ -0,0 +1,17 @@
+<?php
+
+namespace App\Framework\View\Exception;
+
+use App\Framework\Exception\FrameworkException;
+
+class TemplateNotFound extends FrameworkException
+{
+    protected string $template;
+
+    public function __construct(string $template, ?\Throwable $previous = null, int $code = 0, array $context = [])
+    {
+        $this->template = $template;
+        $message = "Das Template '$template' konnte nicht geladen werden.";
+        parent::__construct($message, $code, $previous, $context);
+    }
+}
diff --git a/src/Framework/View/Exceptions/TemplateNotFoundException.php b/src/Framework/View/Exceptions/TemplateNotFoundException.php
new file mode 100644
index 00000000..a52f6b21
--- /dev/null
+++ b/src/Framework/View/Exceptions/TemplateNotFoundException.php
@@ -0,0 +1,27 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\View\Exceptions;
+
+use App\Framework\Exception\FrameworkException;
+
+final class TemplateNotFoundException extends FrameworkException
+{
+    public function __construct(
+        string $template,
+        string $file,
+        int $code = 0,
+        ?\Throwable $previous = null
+    ) {
+        parent::__construct(
+            message: "Template \"$template\" nicht gefunden ($file).",
+            code: $code,
+            previous: $previous,
+            context: [
+                'template' => $template,
+                'file' => $file
+            ]
+        );
+    }
+}
diff --git a/src/Framework/View/Functions/ImageSlotFunction.php b/src/Framework/View/Functions/ImageSlotFunction.php
new file mode 100644
index 00000000..d5142680
--- /dev/null
+++ b/src/Framework/View/Functions/ImageSlotFunction.php
@@ -0,0 +1,35 @@
+<?php
+
+namespace App\Framework\View\Functions;
+
+use App\Domain\Media\ImageSlotRepository;
+use App\Domain\Media\ImageSourceSetGenerator;
+use App\Framework\View\ComponentRenderer;
+
+final readonly class ImageSlotFunction implements TemplateFunction
+{
+    public string $functionName;
+
+    public function __construct(
+        private ImageSlotRepository $imageSlotRepository,
+        private ComponentRenderer $componentRenderer
+    ){
+        $this->functionName = 'imageslot';
+    }
+
+    public function __invoke(string $slotName): string
+    {
+        $image = $this->imageSlotRepository->findBySlotName($slotName)->image;
+
+        $srcGen = new ImageSourceSetGenerator();
+
+        return $srcGen->generatePictureElement($image);
+
+        $data = [
+            'image' => $image->filename,
+            'alt' => $image->altText
+        ];
+
+        return $this->componentRenderer->render('imageslot', $data);
+    }
+}
diff --git a/src/Framework/View/Functions/TemplateFunction.php b/src/Framework/View/Functions/TemplateFunction.php
new file mode 100644
index 00000000..5c8b447b
--- /dev/null
+++ b/src/Framework/View/Functions/TemplateFunction.php
@@ -0,0 +1,8 @@
+<?php
+
+namespace App\Framework\View\Functions;
+
+interface TemplateFunction
+{
+    public string $functionName {get;}
+}
diff --git a/src/Framework/View/Functions/UrlFunction.php b/src/Framework/View/Functions/UrlFunction.php
new file mode 100644
index 00000000..288231cf
--- /dev/null
+++ b/src/Framework/View/Functions/UrlFunction.php
@@ -0,0 +1,21 @@
+<?php
+
+namespace App\Framework\View\Functions;
+
+use App\Framework\Router\UrlGenerator;
+
+final readonly class UrlFunction implements TemplateFunction
+{
+    public function __construct(
+        private UrlGenerator $urlGenerator
+    ){
+        $this->functionName = 'url';
+    }
+
+    public function __invoke(string $namedRoute, array $params = []): string
+    {
+        return $this->urlGenerator->route($namedRoute, $params);
+    }
+
+    public string $functionName;
+}
diff --git a/src/Framework/View/Loading/Resolvers/ControllerResolver.php b/src/Framework/View/Loading/Resolvers/ControllerResolver.php
new file mode 100644
index 00000000..b15ff48a
--- /dev/null
+++ b/src/Framework/View/Loading/Resolvers/ControllerResolver.php
@@ -0,0 +1,24 @@
+<?php
+
+namespace App\Framework\View\Loading\Resolvers;
+
+final readonly class ControllerResolver implements TemplateResolverStrategy
+{
+    const string TEMPLATE_EXTENSION = '.view.php';
+
+    public function resolve(string $template, ?string $controllerClass = null): ?string
+    {
+        if(!$controllerClass) {
+            return null;
+        }
+
+        try {
+            $rc = new \ReflectionClass($controllerClass);
+            $dir = dirname($rc->getFileName());
+            $path = $dir . DIRECTORY_SEPARATOR . $template . self::TEMPLATE_EXTENSION;
+            return file_exists($path) ? $path : null;
+        } catch (\ReflectionException) {
+            return null;
+        }
+    }
+}
diff --git a/src/Framework/View/Loading/Resolvers/DefaultPathResolver.php b/src/Framework/View/Loading/Resolvers/DefaultPathResolver.php
new file mode 100644
index 00000000..6dd842ab
--- /dev/null
+++ b/src/Framework/View/Loading/Resolvers/DefaultPathResolver.php
@@ -0,0 +1,24 @@
+<?php
+
+namespace App\Framework\View\Loading\Resolvers;
+
+use App\Framework\Core\PathProvider;
+
+final readonly class DefaultPathResolver implements TemplateResolverStrategy
+{
+    const string TEMPLATE_EXTENSION = '.view.php';
+
+    public function __construct(
+        private PathProvider $pathProvider,
+        private string $templatePath = '/src/Framework/View/templates'
+    ){}
+
+    public function resolve(string $template, ?string $controllerClass = null): ?string
+    {
+        $path = $this->pathProvider->resolvePath(
+            $this->templatePath . '/' . $template . self::TEMPLATE_EXTENSION
+        );
+
+        return file_exists($path) ? $path : null;
+    }
+}
diff --git a/src/Framework/View/Loading/Resolvers/DiscoveryResolver.php b/src/Framework/View/Loading/Resolvers/DiscoveryResolver.php
new file mode 100644
index 00000000..2185588a
--- /dev/null
+++ b/src/Framework/View/Loading/Resolvers/DiscoveryResolver.php
@@ -0,0 +1,101 @@
+<?php
+
+namespace App\Framework\View\Loading\Resolvers;
+
+use App\Framework\Discovery\Results\DiscoveryResults;
+use App\Framework\View\TemplateDiscoveryVisitor;
+
+final readonly class DiscoveryResolver implements TemplateResolverStrategy
+{
+    const string TEMPLATE_EXTENSION = '.view.php';
+
+    public function __construct(
+        private DiscoveryResults|null $discoverySource = null
+    ) {}
+
+    public function resolve(string $template, ?string $controllerClass = null): ?string
+    {
+        if ($this->discoverySource === null) {
+            return null;
+        }
+
+        return $this->resolveFromDiscoveryResults($template, $controllerClass);
+    }
+
+    private function resolveFromDiscoveryResults(string $template, ?string $controllerClass): ?string
+    {
+        $templates = $this->discoverySource->getTemplates();
+
+        // Strategie 1: Direkter Template-Name-Match
+        if (isset($templates[$template])) {
+            return $this->selectBestTemplate($templates[$template], $controllerClass);
+        }
+
+        // Strategie 2: Template mit Extension
+        $templateWithExt = $template . self::TEMPLATE_EXTENSION;
+        if (isset($templates[$templateWithExt])) {
+            return $this->selectBestTemplate($templates[$templateWithExt], $controllerClass);
+        }
+
+        // Strategie 3: Suche in allen Templates
+        foreach ($templates as $templateName => $templateData) {
+            if ($this->templateMatches($templateName, $template)) {
+                return $this->selectBestTemplate($templateData, $controllerClass);
+            }
+        }
+
+        return null;
+    }
+
+    private function resolveFromTemplateVisitor(string $template, ?string $controllerClass): ?string
+    {
+        $path = $this->discoverySource->getTemplatePath($template, $controllerClass);
+        return ($path && file_exists($path)) ? $path : null;
+    }
+
+    private function selectBestTemplate(mixed $templateData, ?string $controllerClass): ?string
+    {
+        // Wenn templateData ein String ist (direkter Pfad)
+        if (is_string($templateData)) {
+            return file_exists($templateData) ? $templateData : null;
+        }
+
+        // Wenn templateData ein Array ist (mehrere Varianten)
+        if (is_array($templateData)) {
+            // 1. Versuche Controller-spezifisches Template
+            if ($controllerClass && isset($templateData[$controllerClass])) {
+                $path = $templateData[$controllerClass];
+                if (is_string($path) && file_exists($path)) {
+                    return $path;
+                }
+            }
+
+            // 2. Versuche Standard-Template (leerer Key)
+            if (isset($templateData[''])) {
+                $path = $templateData[''];
+                if (is_string($path) && file_exists($path)) {
+                    return $path;
+                }
+            }
+
+            // 3. Nimm das erste verfügbare Template
+            foreach ($templateData as $path) {
+                if (is_string($path) && file_exists($path)) {
+                    return $path;
+                }
+            }
+        }
+
+        return null;
+    }
+
+    private function templateMatches(string $templateName, string $searchTemplate): bool
+    {
+        // Entferne Extension für Vergleich
+        $cleanTemplateName = str_replace(self::TEMPLATE_EXTENSION, '', $templateName);
+
+        return $cleanTemplateName === $searchTemplate ||
+               basename($cleanTemplateName) === $searchTemplate ||
+               str_contains($cleanTemplateName, $searchTemplate);
+    }
+}
diff --git a/src/Framework/View/Loading/Resolvers/TemplateMapResolver.php b/src/Framework/View/Loading/Resolvers/TemplateMapResolver.php
new file mode 100644
index 00000000..c9db9003
--- /dev/null
+++ b/src/Framework/View/Loading/Resolvers/TemplateMapResolver.php
@@ -0,0 +1,19 @@
+<?php
+
+namespace App\Framework\View\Loading\Resolvers;
+
+final readonly class TemplateMapResolver implements TemplateResolverStrategy
+{
+    const string TEMPLATE_EXTENSION = '.view.php';
+    public function __construct(
+        private array $templates = []
+    ){}
+
+    public function resolve(string $template, ?string $controllerClass = null): ?string
+    {
+        $key = $template . self::TEMPLATE_EXTENSION;
+        $path = $this->templates[$key] ?? null;
+
+        return ($path && file_exists($path)) ? $path : null;
+    }
+}
diff --git a/src/Framework/View/Loading/Resolvers/TemplateResolverStrategy.php b/src/Framework/View/Loading/Resolvers/TemplateResolverStrategy.php
new file mode 100644
index 00000000..46e817d1
--- /dev/null
+++ b/src/Framework/View/Loading/Resolvers/TemplateResolverStrategy.php
@@ -0,0 +1,8 @@
+<?php
+
+namespace App\Framework\View\Loading\Resolvers;
+
+interface TemplateResolverStrategy
+{
+    public function resolve(string $template, ?string $controllerClass = null): ?string;
+}
diff --git a/src/Framework/View/Loading/TemplateCache.php b/src/Framework/View/Loading/TemplateCache.php
new file mode 100644
index 00000000..a652410e
--- /dev/null
+++ b/src/Framework/View/Loading/TemplateCache.php
@@ -0,0 +1,40 @@
+<?php
+
+namespace App\Framework\View\Loading;
+
+final class TemplateCache
+{
+    private array $cache = [];
+
+    public function __construct(
+        private readonly bool $enabled = true
+    ) {}
+
+    public function get(string $key): ?string
+    {
+        if (!$this->enabled) {
+            return null;
+        }
+
+        return $this->cache[$key] ?? null;
+    }
+
+    public function set(string $key, string $content): void
+    {
+        if (!$this->enabled) {
+            return;
+        }
+
+        $this->cache[$key] = $content;
+    }
+
+    public function clear(): void
+    {
+        $this->cache = [];
+    }
+
+    public function isEnabled(): bool
+    {
+        return $this->enabled;
+    }
+}
diff --git a/src/Framework/View/Loading/TemplateContentLoader.php b/src/Framework/View/Loading/TemplateContentLoader.php
new file mode 100644
index 00000000..5bf51ea3
--- /dev/null
+++ b/src/Framework/View/Loading/TemplateContentLoader.php
@@ -0,0 +1,22 @@
+<?php
+
+namespace App\Framework\View\Loading;
+
+final readonly class TemplateContentLoader
+{
+    public function load(string $path): string
+    {
+        if (!file_exists($path)) {
+            throw new \RuntimeException("Template file not found: {$path}");
+        }
+
+        $content = @file_get_contents($path);
+
+        if ($content === false) {
+            throw new \RuntimeException("Template could not be read: {$path}");
+        }
+
+        // HTML-Entities dekodieren, damit -> nicht als &gt; erscheint
+        return html_entity_decode($content, ENT_QUOTES | ENT_HTML5, 'UTF-8');
+    }
+}
diff --git a/src/Framework/View/Loading/TemplateLoader.php b/src/Framework/View/Loading/TemplateLoader.php
new file mode 100644
index 00000000..87d4cdf8
--- /dev/null
+++ b/src/Framework/View/Loading/TemplateLoader.php
@@ -0,0 +1,128 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\View\Loading;
+
+use App\Framework\Cache\Cache;
+use App\Framework\Core\PathProvider;
+use App\Framework\Discovery\Results\DiscoveryResults;
+use App\Framework\Filesystem\FileStorage;
+use App\Framework\View\Loading\Resolvers\ControllerResolver;
+use App\Framework\View\Loading\Resolvers\DefaultPathResolver;
+use App\Framework\View\Loading\Resolvers\DiscoveryResolver;
+use App\Framework\View\Loading\Resolvers\TemplateMapResolver;
+use App\Framework\View\Loading\Resolvers\LayoutResolver;
+use App\Framework\View\Loading\Resolvers\ComponentResolver;
+use App\Framework\View\RenderContext;
+use App\Framework\View\TemplateDiscoveryVisitor;
+
+final class TemplateLoader
+{
+    private readonly TemplatePathResolver $pathResolver;
+    private readonly TemplateContentLoader $contentLoader;
+    #private readonly TemplateCache $cache;
+
+    public function __construct(
+        private readonly PathProvider $pathProvider,
+        private readonly Cache $cache,
+        private readonly ?DiscoveryResults $discoveryResults = null,
+        private readonly array $templates = [],
+        private readonly string $templatePath = '/src/Framework/View/templates',
+        private readonly FileStorage $storage = new FileStorage,
+        #private readonly ?TemplateDiscoveryVisitor $templateVisitor = null,
+    ) {
+        $this->pathResolver = $this->createPathResolver();
+        $this->contentLoader = new TemplateContentLoader();
+        #$this->cache = new TemplateCache();
+    }
+
+    private function createPathResolver(): TemplatePathResolver
+    {
+        $resolvers = [
+            // 1. Explizite Template-Map (höchste Priorität)
+            new TemplateMapResolver($this->templates),
+
+            // 2. Discovery-basierte Templates (falls verfügbar)
+            new DiscoveryResolver($this->discoveryResults),
+
+            // 3. Layout-spezifische Suche (für "main" etc.)
+            new LayoutResolver($this->pathProvider, $this->templatePath),
+
+            // 4. Component-spezifische Suche
+            new ComponentResolver($this->pathProvider, $this->templatePath),
+
+            // 5. Controller-basierte Templates
+            new ControllerResolver(),
+
+            // 6. Standard-Pfad (Fallback)
+            new DefaultPathResolver($this->pathProvider, $this->templatePath),
+        ];
+
+        return new TemplatePathResolver($resolvers);
+    }
+
+    public function load(string $template, ?string $controllerClass = null, ?RenderContext $context = null): string
+    {
+        $cacheKey = 'template_content|' . $template . '|' . ($controllerClass ?? 'default');
+
+        return $this->cache->remember($cacheKey, function() use ($template, $controllerClass, $context) {
+            $path = $this->pathResolver->resolve($template, $controllerClass);
+            $content = $this->contentLoader->load($path);
+            return $content;
+        })->value;
+
+        if ($cached = $this->cache->get($cacheKey)) {
+            return $cached;
+        }
+
+        $path = $this->pathResolver->resolve($template, $controllerClass);
+        $content = $this->contentLoader->load($path);
+
+        $this->cache->set($cacheKey, $content);
+        return $content;
+    }
+
+    public function getTemplatePath(string $template, ?string $controllerClass = null): string
+    {
+        return $this->pathResolver->resolve($template, $controllerClass);
+    }
+
+    public function clearCache(): void
+    {
+        $this->cache->clear();
+    }
+
+    public function getComponentPath(string $name): string
+    {
+        return __DIR__ . "/../templates/components/{$name}.html";
+    }
+
+    public function debugTemplatePath(string $template, ?string $controllerClass = null): array
+    {
+        $debug = ['template' => $template, 'attempts' => []];
+
+        $resolvers = [
+            'TemplateMap' => new TemplateMapResolver($this->templates),
+            'Discovery' => new DiscoveryResolver($this->discoveryResults),
+            'Layout' => new LayoutResolver($this->pathProvider, $this->templatePath),
+            'Component' => new ComponentResolver($this->pathProvider, $this->templatePath),
+            'Controller' => new ControllerResolver(),
+            'Default' => new DefaultPathResolver($this->pathProvider, $this->templatePath),
+        ];
+
+        foreach ($resolvers as $name => $resolver) {
+            try {
+                $path = $resolver->resolve($template, $controllerClass);
+                $debug['attempts'][$name] = [
+                    'path' => $path,
+                    'exists' => $path ? file_exists($path) : false,
+                    'success' => $path && file_exists($path)
+                ];
+            } catch (\Exception $e) {
+                $debug['attempts'][$name] = ['error' => $e->getMessage()];
+            }
+        }
+
+        return $debug;
+    }
+}
diff --git a/src/Framework/View/Loading/TemplatePathResolver.php b/src/Framework/View/Loading/TemplatePathResolver.php
new file mode 100644
index 00000000..ec4976d7
--- /dev/null
+++ b/src/Framework/View/Loading/TemplatePathResolver.php
@@ -0,0 +1,23 @@
+<?php
+
+namespace App\Framework\View\Loading;
+
+use App\Framework\View\Exceptions\TemplateNotFoundException;
+
+final readonly class TemplatePathResolver
+{
+    public function __construct(
+        private array $resolvers = []
+    ){}
+
+    public function resolve(string $template, ?string $controllerClass = null): string
+    {
+        foreach($this->resolvers as $resolver) {
+            if($path = $resolver->resolve($template, $controllerClass)) {
+                return $path;
+            }
+        }
+
+        throw new TemplateNotFoundException($template, $controllerClass ?? '');
+    }
+}
diff --git a/src/Framework/View/Processing/DomProcessingPipeline.php b/src/Framework/View/Processing/DomProcessingPipeline.php
new file mode 100644
index 00000000..e75cefaa
--- /dev/null
+++ b/src/Framework/View/Processing/DomProcessingPipeline.php
@@ -0,0 +1,31 @@
+<?php
+
+namespace App\Framework\View\Processing;
+
+use App\Framework\View\DOMTemplateParser;
+use App\Framework\View\DomWrapper;
+use App\Framework\View\ProcessorResolver;
+use App\Framework\View\RenderContext;
+
+final class DomProcessingPipeline
+{
+    public function __construct(
+        private readonly array $processors,
+        private ProcessorResolver $resolver,
+    )
+    {
+    }
+
+    public function process(RenderContext $context, string $html): DomWrapper
+    {
+        $parser = new DOMTemplateParser();
+        $dom = $parser->parseToWrapper($html);
+
+        foreach($this->processors as $processorClass) {
+            $processor = $this->resolver->resolve($processorClass);
+
+            $dom = $processor->process($dom, $context);
+        }
+        return $dom;
+    }
+}
diff --git a/src/Framework/View/Processing/StringProcessingPipeline.php b/src/Framework/View/Processing/StringProcessingPipeline.php
new file mode 100644
index 00000000..58b26979
--- /dev/null
+++ b/src/Framework/View/Processing/StringProcessingPipeline.php
@@ -0,0 +1,25 @@
+<?php
+
+namespace App\Framework\View\Processing;
+
+use App\Framework\View\ProcessorResolver;
+use App\Framework\View\RenderContext;
+
+final readonly class StringProcessingPipeline
+{
+    public function __construct(
+        private array             $processors,
+        private ProcessorResolver $resolver,
+    )
+    {
+    }
+
+    public function process(string $html, RenderContext $context): string
+    {
+        foreach ($this->processors as $processorClass) {
+            $processor = $this->resolver->resolve($processorClass);
+            $html = $processor->process($html, $context);
+        }
+        return $html;
+    }
+}
diff --git a/src/Framework/View/ProcessorResolver.php b/src/Framework/View/ProcessorResolver.php
new file mode 100644
index 00000000..49ef0f36
--- /dev/null
+++ b/src/Framework/View/ProcessorResolver.php
@@ -0,0 +1,21 @@
+<?php
+
+namespace App\Framework\View;
+
+use App\Framework\DI\Container;
+
+final class ProcessorResolver
+{
+    private array $resolvedProcessors = [];
+    public function __construct(
+        private readonly Container $container,
+    ){}
+
+    public function resolve(string $processorClass): object
+    {
+        if(!isset($this->resolvedProcessors[$processorClass])) {
+            $this->resolvedProcessors[$processorClass] = $this->container->get($processorClass);
+        }
+        return $this->resolvedProcessors[$processorClass];
+    }
+}
diff --git a/src/Framework/View/Processors/AssetInjector.php b/src/Framework/View/Processors/AssetInjector.php
new file mode 100644
index 00000000..4c6905c9
--- /dev/null
+++ b/src/Framework/View/Processors/AssetInjector.php
@@ -0,0 +1,74 @@
+<?php
+
+namespace App\Framework\View\Processors;
+
+use App\Framework\Core\PathProvider;
+use App\Framework\View\DomHeadService;
+use App\Framework\View\DomProcessor;
+use App\Framework\View\DomWrapper;
+use Dom\HTMLDocument;
+use DOMDocument;
+use DOMElement;
+use App\Framework\View\RenderContext;
+
+final class AssetInjector implements DomProcessor
+{
+    private array $manifest;
+
+    public function __construct(
+        PathProvider $pathProvider,
+        private DomHeadService $headService,
+        string $manifestPath = '',
+    )
+    {
+
+        $manifestPath = $pathProvider->resolvePath('/public/.vite/manifest.json');;
+
+        #$manifestPath = dirname(__DIR__, 3) . '../public/.vite/manifest.json';
+
+
+        if (!is_file($manifestPath)) {
+            throw new \RuntimeException("Vite manifest not found: $manifestPath");
+        }
+        $json = file_get_contents($manifestPath);
+
+        $this->manifest = json_decode($json, true) ?? [];
+    }
+
+    public function process(DomWrapper $dom, RenderContext $context): DomWrapper
+    {
+        // JS-Key, wie im Manifest unter "resources/js/main.js"
+        $jsKey = 'resources/js/main.js';
+        // CSS-Key, wie im Manifest unter "resources/css/styles.css"
+        $cssKey = 'resources/css/styles.css';
+
+        #$head = $dom->getElementsByTagName('head')->item(0);
+        $head = $dom->document->head;
+        $insertParent = $head ?: $dom->document->getElementsByTagName('body')->item(0) ?: $dom->document->documentElement;
+
+        // --- CSS, wie von Vite empfohlen: Feld "css" beim js-Eintrag! ---
+        if (!empty($this->manifest[$jsKey]['css']) && is_array($this->manifest[$jsKey]['css'])) {
+            foreach ($this->manifest[$jsKey]['css'] as $cssFile) {
+
+                $this->headService->addStylesheet($dom, '/' . ltrim($cssFile, '/'));
+
+                /*$link = $dom->document->createElement('link');
+                $link->setAttribute('rel', 'stylesheet');
+                $link->setAttribute('href', '/' . ltrim($cssFile, '/'));
+                $insertParent->appendChild($link);*/
+            }
+        }
+
+        // --- JS Main Script ---
+        if (isset($this->manifest[$jsKey]['file']) && str_ends_with($this->manifest[$jsKey]['file'], '.js')) {
+
+            $this->headService->addScript($dom, '/' . ltrim($this->manifest[$jsKey]['file'], '/'));
+            /*$script = $dom->document->createElement('script');
+            $script->setAttribute('src', '/' . ltrim($this->manifest[$jsKey]['file'], '/'));
+            $script->setAttribute('type', 'module');
+            $insertParent->appendChild($script);*/
+        }
+
+        return $dom;
+    }
+}
diff --git a/src/Framework/View/Processors/CommentStripProcessor.php b/src/Framework/View/Processors/CommentStripProcessor.php
index b1d4d8ac..ab0aaa69 100644
--- a/src/Framework/View/Processors/CommentStripProcessor.php
+++ b/src/Framework/View/Processors/CommentStripProcessor.php
@@ -3,16 +3,31 @@
 namespace App\Framework\View\Processors;
 
 use App\Framework\View\DomProcessor;
+use App\Framework\View\DomWrapper;
 use App\Framework\View\RenderContext;
+use Dom\HTMLDocument;
+use Dom\Node;
 
 final readonly class CommentStripProcessor implements DomProcessor
 {
 
-    public function process(\DOMDocument $dom, RenderContext $context): void
+    public function process(DomWrapper $dom, RenderContext $context): DomWrapper
     {
-        $xpath = new \DOMXPath($dom);
-        foreach ($xpath->query('//comment()') as $commentNode) {
-            $commentNode->parentNode?->removeChild($commentNode);
+        $this->removeComments($dom->document);
+        return $dom;
+    }
+
+    private function removeComments(Node $node): void
+    {
+        // Wir gehen rekursiv durch alle Childnodes
+        for ($i = $node->childNodes->length - 1; $i >= 0; $i--) {
+            $child = $node->childNodes->item($i);
+            if ($child->nodeType === XML_COMMENT_NODE) {
+                $node->removeChild($child);
+            } else {
+                // Rekursion in die nächste Ebene
+                $this->removeComments($child);
+            }
         }
     }
 }
diff --git a/src/Framework/View/Processors/ComponentProcessor.php b/src/Framework/View/Processors/ComponentProcessor.php
index 2a8980b2..b20c7af4 100644
--- a/src/Framework/View/Processors/ComponentProcessor.php
+++ b/src/Framework/View/Processors/ComponentProcessor.php
@@ -3,35 +3,52 @@
 namespace App\Framework\View\Processors;
 
 use App\Framework\View\ComponentRenderer;
+use App\Framework\View\DomComponentService;
 use App\Framework\View\DomProcessor;
+use App\Framework\View\DomWrapper;
 use App\Framework\View\RenderContext;
+use Dom\HTMLElement;
 
+/**
+ * Erweiterte Version des ComponentProcessors mit DomWrapper-Unterstützung
+ */
 final readonly class ComponentProcessor implements DomProcessor
 {
     public function __construct(
-        private ComponentRenderer $renderer = new ComponentRenderer()
-    ){}
+        private DomComponentService $componentService,
+        private ComponentRenderer $renderer
+    ) {}
 
-    public function process(\DOMDocument $dom, RenderContext $context): void
+    public function process(DomWrapper $dom, RenderContext $context): DomWrapper
     {
-        $xpath = new \DOMXPath($dom);
+        $components = $dom->getElementsByTagName('component');
 
-        foreach ($xpath->query('//component') as $node) {
-            $name = $node->getAttribute('name');
-            $attributes = [];
+        $components->forEach(function ($component) use ($context, $dom) {
+            /** @var HTMLElement $component */
+            $name = $component->getAttribute('name');
 
-            foreach ($node->attributes as $attr) {
-                if($attr->nodeName !== 'name') {
-                    $attributes[$attr->nodeName] = $attr->nodeValue;
-                }
-            }
+            if(!$name) return;
+
+            $attributes = $this->extractAttributes($component);
 
             $componentHtml = $this->renderer->render($name, array_merge($context->data, $attributes));
 
-            $fragment = $dom->createDocumentFragment();
-            $fragment->appendXML($componentHtml);
+            $this->componentService->replaceComponent($dom, $component, $componentHtml);
+            #$dom->replaceElementWithHtml($component, $componentHtml);
 
-            $node->parentNode->replaceChild($fragment, $node);
+        });
+
+        return $dom;
+    }
+
+    private function extractAttributes(HTMLElement $component): array
+    {
+        $attributes = [];
+        foreach ($component->attributes as $attr) {
+            if ($attr->nodeName !== 'name') {
+                $attributes[$attr->nodeName] = $attr->nodeValue;
+            }
         }
+        return $attributes;
     }
 }
diff --git a/src/Framework/View/Processors/CsrfReplaceProcessor.php b/src/Framework/View/Processors/CsrfReplaceProcessor.php
new file mode 100644
index 00000000..08b6b046
--- /dev/null
+++ b/src/Framework/View/Processors/CsrfReplaceProcessor.php
@@ -0,0 +1,71 @@
+<?php
+
+namespace App\Framework\View\Processors;
+
+use App\Framework\Http\Session\Session;
+use App\Framework\View\RenderContext;
+use App\Framework\View\StringProcessor;
+
+readonly class CsrfReplaceProcessor implements StringProcessor
+{
+    public function __construct(
+        private Session $session,
+    ){}
+
+    public function process(string $html, RenderContext $context): string
+    {
+        if(!str_contains($html, '___TOKEN___')){
+            // No token to replace
+            return $html;
+        }
+
+
+        $formIds = $this->extractFormIdsFromHtml($html);
+
+        if (empty($formIds)) {
+            return $html;
+        }
+
+        // Für jede gefundene Form-ID das entsprechende Token generieren
+        foreach ($formIds as $formId) {
+            $token = $this->session->csrf->generateToken($formId);
+            // Token-Platzhalter für diese spezifische Form-ID ersetzen
+            $html = $this->replaceTokenForFormId($html, $formId, $token);
+        }
+
+        return $html;
+
+        #$csrf->setAttribute('value', $this->session->csrf->generateToken($formId));
+    }
+
+    private function extractFormIdsFromHtml(string $html): array
+    {
+        $formIds = [];
+
+        // Pattern für Form-ID: value="form_xxxxx"
+        if (preg_match_all('/value=["\']form_([^"\']+)["\']/', $html, $matches)) {
+            foreach ($matches[1] as $match) {
+                $formId = 'form_' . $match;
+                if (!in_array($formId, $formIds)) {
+                    $formIds[] = $formId;
+                }
+            }
+        }
+
+        return $formIds;
+
+    }
+
+    private function replaceTokenForFormId(string $html, string $formId, string $token): string
+    {
+        // Suche nach dem Token-Platzhalter, der zur entsprechenden Form-ID gehört
+        // Wir müssen den Kontext der Form berücksichtigen
+        $pattern = '/(<form[^>]*>.*?<input[^>]*name=["\']_form_id["\'][^>]*value=["\']' . preg_quote($formId, '/') . '["\'][^>]*>.*?)<input[^>]*name=["\']_token["\'][^>]*value=["\']___TOKEN___["\'][^>]*>/s';
+
+        return preg_replace_callback($pattern, function($matches) use ($token) {
+            return str_replace('___TOKEN___', $token, $matches[0]);
+        }, $html);
+    }
+
+
+}
diff --git a/src/Framework/View/Processors/EscapeProcessor.php b/src/Framework/View/Processors/EscapeProcessor.php
index 4178a57a..1cd00e65 100644
--- a/src/Framework/View/Processors/EscapeProcessor.php
+++ b/src/Framework/View/Processors/EscapeProcessor.php
@@ -3,8 +3,9 @@
 namespace App\Framework\View\Processors;
 
 use App\Framework\View\RenderContext;
+use App\Framework\View\StringProcessor;
 
-final readonly class EscapeProcessor
+final readonly class EscapeProcessor implements StringProcessor
 {
     public function process(string $html, RenderContext $context): string
     {
diff --git a/src/Framework/View/Processors/Exceptions/ViteManifestNotFoundException.php b/src/Framework/View/Processors/Exceptions/ViteManifestNotFoundException.php
new file mode 100644
index 00000000..8e64233d
--- /dev/null
+++ b/src/Framework/View/Processors/Exceptions/ViteManifestNotFoundException.php
@@ -0,0 +1,23 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\View\Processors\Exceptions;
+
+use App\Framework\Exception\FrameworkException;
+
+final class ViteManifestNotFoundException extends FrameworkException
+{
+    public function __construct(
+        string $manifestPath,
+        int $code = 0,
+        ?\Throwable $previous = null
+    ) {
+        parent::__construct(
+            message: "Vite manifest not found: $manifestPath",
+            code: $code,
+            previous: $previous,
+            context: ['manifestPath' => $manifestPath]
+        );
+    }
+}
diff --git a/src/Framework/View/Processors/ForProcessor.php b/src/Framework/View/Processors/ForProcessor.php
index 499e7fe8..d3d42f72 100644
--- a/src/Framework/View/Processors/ForProcessor.php
+++ b/src/Framework/View/Processors/ForProcessor.php
@@ -2,58 +2,71 @@
 
 namespace App\Framework\View\Processors;
 
+use App\Framework\DI\Container;
+use App\Framework\Meta\MetaData;
 use App\Framework\View\DomProcessor;
+use App\Framework\View\DomWrapper;
+use App\Framework\View\RenderContext;
+use App\Framework\View\TemplateProcessor;
 
 final class ForProcessor implements DomProcessor
 {
+    public function __construct(
+        private Container $container,
+        private ?TemplateProcessor $templateProcessor = null,
+
+    ) {
+        // Falls kein TemplateProcessor übergeben wird, erstellen wir einen mit den Standard-Prozessoren
+        if ($this->templateProcessor === null) {
+            #$this->templateProcessor = new TemplateProcessor([],[PlaceholderReplacer::class], $this->container);
+            #$this->templateProcessor->register(PlaceholderReplacer::class);
+            $this->templateProcessor = $this->container->get(TemplateProcessor::class);
+        }
+    }
 
     /**
      * @inheritDoc
      */
-    public function process(\DOMDocument $dom, RenderContext $context): void
+    public function process(DomWrapper $dom, RenderContext $context): DomWrapper
     {
-        $xpath = new \DOMXPath($dom);
-
-        foreach ($xpath->query('//for[@var][@in]') as $node) {
+        foreach ($dom->document->querySelectorAll('for[var][in]') as $node) {
             $var = $node->getAttribute('var');
             $in = $node->getAttribute('in');
 
             $output = '';
 
-            if (isset($context->data[$in]) && is_iterable($context->data[$in])) {
-                foreach ($context->data[$in] as $item) {
+            $items = $context->data[$in] ?? null;
+            if (isset($context->model->{$in}) && $items === null) {
+                $items = $context->model->{$in};
+            }
+
+            if (is_iterable($items)) {
+                foreach ($items as $item) {
                     $clone = $node->cloneNode(true);
-                    foreach ($clone->childNodes as $child) {
-                        $this->replacePlaceholdersRecursive($child, [$var => $item] + $context->data);
-                    }
 
-                    $fragment = $dom->createDocumentFragment();
-                    foreach ($clone->childNodes as $child) {
-                        $fragment->appendChild($child->cloneNode(true));
-                    }
+                    // Neuen Kontext für die Schleifenvariable erstellen
+                    $loopContext = new RenderContext(
+                        template: $context->template,
+                        metaData: new MetaData('', ''),
+                        data: array_merge($context->data, [$var => $item]),
+                        #model: $context->model,
+                        controllerClass: $context->controllerClass
+                    );
 
-                    $output .= $dom->saveHTML($fragment);
+                    // Den Inhalt der Schleife mit den bestehenden Prozessoren verarbeiten
+                    $innerHTML = $clone->innerHTML;
+
+                    $processedContent = $this->templateProcessor->render($loopContext, $innerHTML, true);
+
+                    $output .= $processedContent;
                 }
             }
 
-            $replacement = $dom->createDocumentFragment();
+            $replacement = $dom->document->createDocumentFragment();
             @$replacement->appendXML($output);
             $node->parentNode?->replaceChild($replacement, $node);
         }
-    }
 
-    private function replacePlaceholdersRecursive(\DOMNode $node, array $data): void
-    {
-        if ($node->nodeType === XML_TEXT_NODE) {
-            $node->nodeValue = preg_replace_callback('/{{\s*(\w+)\s*}}/', function ($matches) use ($data) {
-                return htmlspecialchars((string)($data[$matches[1]] ?? $matches[0]), ENT_QUOTES | ENT_HTML5);
-            }, $node->nodeValue);
-        }
-
-        if ($node->hasChildNodes()) {
-            foreach ($node->childNodes as $child) {
-                $this->replacePlaceholdersRecursive($child, $data);
-            }
-        }
+        return $dom;
     }
 }
diff --git a/src/Framework/View/Processors/FormProcessor.php b/src/Framework/View/Processors/FormProcessor.php
new file mode 100644
index 00000000..6849e09c
--- /dev/null
+++ b/src/Framework/View/Processors/FormProcessor.php
@@ -0,0 +1,82 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\View\Processors;
+
+use App\Framework\Http\Session\Session;
+use App\Framework\View\DomFormService;
+use App\Framework\View\DomProcessor;
+use App\Framework\View\DomWrapper;
+use App\Framework\View\RenderContext;
+use Dom\HTMLElement;
+
+final readonly class FormProcessor implements DomProcessor
+{
+    public function __construct(
+        private DomFormService $formService,
+        #private Session $session,
+    ) {}
+
+    public function process(DomWrapper $dom, RenderContext $context): DomWrapper
+    {
+        $forms = $dom->document->querySelectorAll('form');
+
+        /** @var HTMLElement $form */
+        foreach($forms as $form) {
+
+            $formId = $this->generateFormId($form, $context);
+
+            $csrf = $dom->document->createElement('input');
+            $csrf->setAttribute('name', '_token');
+            $csrf->setAttribute('type', 'hidden');
+            $csrf->setAttribute('value', '___TOKEN___');
+            #$csrf->setAttribute('value', $this->session->csrf->generateToken($formId));
+
+            // Form ID
+            $formIdField = $dom->document->createElement('input');
+            $formIdField->setAttribute('name', '_form_id');
+            $formIdField->setAttribute('type', 'hidden');
+            $formIdField->setAttribute('value', $formId);
+
+            $form->insertBefore($csrf, $form->firstChild);
+            $form->insertBefore($formIdField, $form->firstChild);;
+
+        }
+
+        return $dom;
+    }
+
+    private function generateFormId(HTMLElement $form, RenderContext $context): string
+    {
+        // 1. Vorhandene ID verwenden, falls gesetzt
+        if ($existingId = $form->getAttribute('id')) {
+            return $existingId;
+        }
+
+        // 2. Hash aus charakteristischen Eigenschaften erstellen
+        $hashComponents = [
+            $context->route ?? 'unknown_route',
+            $form->getAttribute('action') ?? '',
+            $form->getAttribute('method') ?? 'post',
+            $this->getFormStructureHash($form)
+        ];
+
+        return 'form_' . substr(hash('sha256', implode('|', $hashComponents)), 0, 12);
+    }
+
+    private function getFormStructureHash(HTMLElement $form): string
+    {
+        // Hash aus Formular-Struktur (Input-Namen) erstellen
+        $inputs = $form->querySelectorAll('input[name], select[name], textarea[name]');
+        $names = [];
+
+        foreach ($inputs as $input) {
+            if ($name = $input->getAttribute('name')) {
+                $names[] = $name;
+            }
+        }
+
+        sort($names); // Sortieren für konsistente Hashes
+        return hash('crc32', implode(',', $names));
+    }
+}
diff --git a/src/Framework/View/Processors/HoneypotProcessor.php b/src/Framework/View/Processors/HoneypotProcessor.php
new file mode 100644
index 00000000..1c02d732
--- /dev/null
+++ b/src/Framework/View/Processors/HoneypotProcessor.php
@@ -0,0 +1,78 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\View\Processors;
+
+use App\Framework\View\DomProcessor;
+use App\Framework\View\DomWrapper;
+use App\Framework\View\RenderContext;
+use Dom\HTMLDocument;
+use Dom\HTMLElement;
+
+final readonly class HoneypotProcessor implements DomProcessor
+{
+    private const array HONEYPOT_NAMES = [
+        'email_confirm',
+        'website_url',
+        'phone_number',
+        'user_name',
+        'company_name'
+    ];
+
+    public function process(DomWrapper $dom, RenderContext $context): DomWrapper
+    {
+        $forms = $dom->document->querySelectorAll('form');
+
+        /** @var HTMLElement $form */
+        foreach($forms as $form) {
+            $this->addHoneypot($dom->document, $form);
+            $this->addTimeValidation($dom->document, $form);
+        }
+
+        return $dom;
+    }
+
+    private function addHoneypot(HTMLDocument $dom, HTMLElement $form): void
+    {
+        $honeypotName = self::HONEYPOT_NAMES[array_rand(self::HONEYPOT_NAMES)];
+
+        // Versteckter Container
+        $container = $dom->createElement('div');
+        $container->setAttribute('style', 'position:absolute;left:-9999px;visibility:hidden;');
+        $container->setAttribute('aria-hidden', 'true');
+
+        // Honeypot mit realistischem Label
+        $label = $dom->createElement('label');
+        $label->textContent = 'Website (optional)';
+        $label->setAttribute('for', $honeypotName);
+
+        $honeypot = $dom->createElement('input');
+        $honeypot->setAttribute('type', 'text');
+        $honeypot->setAttribute('name', $honeypotName);
+        $honeypot->setAttribute('id', $honeypotName);
+        $honeypot->setAttribute('autocomplete', 'off');
+        $honeypot->setAttribute('tabindex', '-1');
+
+        $container->appendChild($label);
+        $container->appendChild($honeypot);
+
+        // Honeypot-Name als verstecktes Feld
+        $nameField = $dom->createElement('input');
+        $nameField->setAttribute('type', 'hidden');
+        $nameField->setAttribute('name', '_honeypot_name');
+        $nameField->setAttribute('value', $honeypotName);
+
+        $form->insertBefore($container, $form->firstChild);
+        $form->insertBefore($nameField, $form->firstChild);
+    }
+
+    private function addTimeValidation(HTMLDocument $dom, HTMLElement $form): void
+    {
+        $timeField = $dom->createElement('input');
+        $timeField->setAttribute('type', 'hidden');
+        $timeField->setAttribute('name', '_form_start_time');
+        $timeField->setAttribute('value', (string)time());
+
+        $form->insertBefore($timeField, $form->firstChild);
+    }
+}
diff --git a/src/Framework/View/Processors/IfProcessor.php b/src/Framework/View/Processors/IfProcessor.php
index c8d1058d..6cfdefaa 100644
--- a/src/Framework/View/Processors/IfProcessor.php
+++ b/src/Framework/View/Processors/IfProcessor.php
@@ -3,14 +3,30 @@
 namespace App\Framework\View\Processors;
 
 use App\Framework\View\DomProcessor;
+use App\Framework\View\DomWrapper;
+use App\Framework\View\RenderContext;
 
 final readonly class IfProcessor implements DomProcessor
 {
-    public function process(\DOMDocument $dom, \App\Framework\View\RenderContext $context): void
+    public function process(DomWrapper $dom, RenderContext $context): DomWrapper
     {
-        $xpath = new \DOMXPath($dom);
+        $dom->getELementsByAttribute('if')->forEach(function ($node) use ($context) {
+            $condition = $node->getAttribute('if');
 
-        foreach ($xpath->query('//*[@if]') as $node) {
+            $value = $context->data[$condition] ?? null;
+
+            // Entferne, wenn die Bedingung nicht erfüllt ist
+            if (!$this->isTruthy($value)) {
+                $node->parentNode?->removeChild($node);
+            } else {
+                // Entferne Attribut bei Erfolg
+                $node->removeAttribute('if');
+            }
+        });
+
+
+
+        /*foreach ($dom->querySelectorAll('*[if]') as $node) {
             $condition = $node->getAttribute('if');
 
             $value = $context->data[$condition] ?? null;
@@ -23,7 +39,9 @@ final readonly class IfProcessor implements DomProcessor
 
             // Entferne Attribut bei Erfolg
             $node->removeAttribute('if');
-        }
+        }*/
+
+        return $dom;
     }
 
     private function isTruthy(mixed $value): bool
diff --git a/src/Framework/View/Processors/IncludeProcessor.php b/src/Framework/View/Processors/IncludeProcessor.php
index 6b25211d..9e70fc60 100644
--- a/src/Framework/View/Processors/IncludeProcessor.php
+++ b/src/Framework/View/Processors/IncludeProcessor.php
@@ -4,8 +4,10 @@ namespace App\Framework\View\Processors;
 
 use App\Framework\View\DomProcessor;
 use App\Framework\View\DomTemplateParser;
+use App\Framework\View\DomWrapper;
+use App\Framework\View\Loading\TemplateLoader;
 use App\Framework\View\RenderContext;
-use App\Framework\View\TemplateLoader;
+use Dom\HTMLDocument;
 
 final readonly class IncludeProcessor implements DomProcessor
 {
@@ -14,16 +16,14 @@ final readonly class IncludeProcessor implements DomProcessor
         private DomTemplateParser $parser = new DomTemplateParser()
     ) {}
 
-    public function process(\DOMDocument $dom, RenderContext $context): void
+    public function process(DomWrapper $dom, RenderContext $context): DomWrapper
     {
-        $xpath = new \DOMXPath($dom);
-
-        foreach ($xpath->query('//include[@file]') as $includeNode) {
+        foreach ($dom->querySelectorAll('include[file]') as $includeNode) {
             $file = $includeNode->getAttribute('file');
 
             try {
                 $html = $this->loader->load($file);
-                $includedDom = $this->parser->parse($html);
+                $includedDom = $this->parser->parseFile($html);
 
                 $fragment = $dom->createDocumentFragment();
                 foreach ($includedDom->documentElement->childNodes as $child) {
@@ -37,5 +37,7 @@ final readonly class IncludeProcessor implements DomProcessor
                 $includeNode->parentNode?->replaceChild($error, $includeNode);
             }
         }
+
+        return $dom;
     }
 }
diff --git a/src/Framework/View/Processors/LayoutTagProcessor.php b/src/Framework/View/Processors/LayoutTagProcessor.php
index fe5c64f6..09718bbc 100644
--- a/src/Framework/View/Processors/LayoutTagProcessor.php
+++ b/src/Framework/View/Processors/LayoutTagProcessor.php
@@ -2,101 +2,55 @@
 
 namespace App\Framework\View\Processors;
 
-use App\Framework\View\DomTemplateParser;
-use App\Framework\View\RenderContext;
-use App\Framework\View\TemplateLoader;
 use App\Framework\View\DomProcessor;
+use App\Framework\View\DomTemplateParser;
+use App\Framework\View\DomWrapper;
+use App\Framework\View\Loading\TemplateLoader;
+use App\Framework\View\RenderContext;
+use Dom\Element;
 
 final readonly class LayoutTagProcessor implements DomProcessor
 {
     public function __construct(
-        private TemplateLoader $loader = new TemplateLoader(),
+        private TemplateLoader $loader,
         private DomTemplateParser $parser = new DomTemplateParser()
-    ) {}
+    ) {
+        #$this->loader = new TemplateLoader($this->pathProvider);
+    }
 
-    public function process(\DOMDocument $dom, RenderContext $context): void
+    public function process(DomWrapper $dom, RenderContext $context): DomWrapper
     {
-        $xpath = new \DOMXPath($dom);
-        $layoutTags = $xpath->query('//layout[@src]');
+        $layoutTag = $this->findLayoutTag($dom);
 
-        if ($layoutTags->length === 0) {
-            return;
+        if (!$layoutTag) {
+            return $dom;
         }
 
-        $layoutTag = $layoutTags->item(0);
+        return $this->applyLayout($layoutTag, $dom);
+    }
+
+    private function findLayoutTag(DomWrapper $dom): ?Element
+    {
+        $dom = $dom->document;
+        $layoutTags = $dom->querySelectorAll('layout[src]');
+        return $layoutTags->length > 0 ? $layoutTags->item(0) : null;
+    }
+
+    private function applyLayout(Element $layoutTag, DomWrapper $dom): DomWrapper
+    {
         $layoutFile = $layoutTag->getAttribute('src');
-        $layoutHtml = $this->loader->load('/layouts/'.$layoutFile);
-        $layoutDom = $this->parser->parse($layoutHtml);
 
+        $layoutPath = $this->loader->getTemplatePath($layoutFile);
 
-        // Body-Slot finden
-        $layoutXPath = new \DOMXPath($layoutDom);
-        /*$slotNodes = $layoutXPath->query('//slot[@name="body"]');
+        $layoutDom = $this->parser->parseFileToWrapper($layoutPath);
+        $slot = $layoutDom->document->querySelector('main');
 
-        if ($slotNodes->length === 0) {
-            return;
+        if (!$slot) {
+            return $dom; // Kein Slot verfügbar
         }
 
-        $slot = $slotNodes->item(0);*/
+        $slot->innerHTML = $layoutTag->innerHTML;
 
-        $slot = $layoutXPath->query('//main')->item(0);
-
-        if (! $slot) {
-            return; // Kein <main> vorhanden → Layout kann nicht angewendet werden
-        }
-
-        // Die Kindknoten des ursprünglichen <layout>-Elternelements einsammeln (ohne <layout>-Tag selbst)
-        $parent = $layoutTag->parentNode;
-
-        // Alle Knoten nach <layout> einsammeln (direkt nach <layout>)
-        $contentNodes = [];
-        for ($node = $layoutTag->nextSibling; $node !== null; $node = $node->nextSibling) {
-            $contentNodes[] = $node;
-        }
-
-        // Vor dem Entfernen: Layout-Tag aus DOM löschen
-        $parent->removeChild($layoutTag);
-
-        // Inhalt einfügen
-        $fragment = $layoutDom->createDocumentFragment();
-        foreach ($contentNodes as $contentNode) {
-            // Hole alle noch im Original existierenden Nodes...
-            $fragment->appendChild($layoutDom->importNode($contentNode, true));
-        }
-
-        // <main> ersetzen
-        $slot->parentNode->replaceChild($fragment, $slot);
-
-        // Ersetze gesamtes DOM
-        $newDom = $this->parser->parse($layoutDom->saveHTML());
-        $dom->replaceChild(
-            $dom->importNode($newDom->documentElement, true),
-            $dom->documentElement
-        );
-
-        return;
-
-
-        // Layout-Tag aus Original entfernen
-        $layoutTag->parentNode?->removeChild($layoutTag);
-
-        // Inhalt des Haupttemplates extrahieren (ohne das Layout-Tag selbst)
-        $fragment = $dom->createDocumentFragment();
-
-
-        foreach ($dom->documentElement->childNodes as $child) {
-            $fragment->appendChild($layoutDom->importNode($child, true));
-        }
-
-        // Ersetze Slot im Layout durch den gerenderten Body
-        $slot->parentNode?->replaceChild($fragment, $slot);
-
-        // Ersetze gesamtes DOM durch Layout-DOM
-        $newDom = $this->parser->parse($layoutDom->saveHTML());
-
-        $dom->replaceChild(
-            $dom->importNode($newDom->documentElement, true),
-            $dom->documentElement
-        );
+        return $layoutDom;
     }
 }
diff --git a/src/Framework/View/Processors/MetaManipulator.php b/src/Framework/View/Processors/MetaManipulator.php
index 3a8f46a2..1f20c6ac 100644
--- a/src/Framework/View/Processors/MetaManipulator.php
+++ b/src/Framework/View/Processors/MetaManipulator.php
@@ -2,23 +2,46 @@
 
 namespace App\Framework\View\Processors;
 
+use App\Framework\Meta\OpenGraphType;
 use App\Framework\View\DomProcessor;
+use App\Framework\View\DomWrapper;
 use App\Framework\View\RenderContext;
+use Dom\HTMLDocument;
 
 final readonly class MetaManipulator implements DomProcessor
 {
-    public function process(\DOMDocument $dom, RenderContext $context): void
+    public function process(DomWrapper $dom, RenderContext $context): DomWrapper
     {
-        $xpath = new \DOMXPath($dom);
+        $description = $context->metaData->description;
 
-        foreach ($xpath->query('//meta[@name][@content]') as $meta) {
+
+        $dom->document->head->querySelector('meta[name="description"]')?->setAttribute('content', $description);
+
+        if($dom->document->head->getElementsByTagName('title')->item(0)) {
+            $dom->document->head->getElementsByTagName('title')->item(0)->textContent = $context->metaData->title . " | Michael Schiemer";
+        }
+
+
+        match($context->metaData->openGraph->type)
+        {
+            OpenGraphType::WEBSITE => $dom->document->head->querySelector('meta[property="og:type"]')?->setAttribute('content', 'website'),
+            default => throw new \Exception('Unexpected match value'),
+        };
+
+
+        foreach ($dom->document->querySelectorAll('meta[name][content]') as $meta) {
             $name = $meta->getAttribute('name');
             $content = $meta->getAttribute('content');
 
+
+            #debug($name);
+
             // Wenn Variable bereits im Context gesetzt ist, nicht überschreiben
-            if (!array_key_exists($name, $context->data)) {
-                $context->data[$name] = $content;
-            }
+            #if (!array_key_exists($name, $context->data)) {
+            #    $context->data[$name] = $content;
+            #}
         }
+
+        return $dom;
     }
 }
diff --git a/src/Framework/View/Processors/PhpVariableProcessor.php b/src/Framework/View/Processors/PhpVariableProcessor.php
new file mode 100644
index 00000000..1405d658
--- /dev/null
+++ b/src/Framework/View/Processors/PhpVariableProcessor.php
@@ -0,0 +1,428 @@
+<?php
+
+namespace App\Framework\View\Processors;
+
+use App\Framework\View\StringProcessor;
+use App\Framework\View\RenderContext;
+
+/**
+ * Ersetzt PHP-Variable-Syntax durch tatsächliche Werte
+ */
+final class PhpVariableProcessor implements StringProcessor
+{
+    private array $allowedFunctions = [
+        // String-Funktionen
+        'strtoupper', 'strtolower', 'ucfirst', 'ucwords', 'trim',
+        'strlen', 'substr', 'str_replace', 'htmlspecialchars',
+
+        // Datum/Zeit
+        'date', 'strftime', 'gmdate',
+
+        // Formatierung
+        'number_format', 'sprintf',
+
+        // Array-Funktionen
+        'count', 'implode', 'array_keys', 'array_values',
+
+        // Custom Template-Funktionen
+        'format_date', 'format_currency', 'format_filesize',
+
+        'print_r', 'get_class'
+    ];
+
+    public function process(string $html, RenderContext $context): string
+    {
+        $data = $context->data ?? [];
+
+        // Stellen wir sicher, dass HTML-Entities dekodiert sind
+        // Dies deckt Fälle ab, in denen das Template bereits HTML-Entities enthält
+        $html = html_entity_decode($html, ENT_QUOTES | ENT_HTML5, 'UTF-8');
+
+        // 2. Funktions-Aufrufe: date('Y-m-d'), strtoupper($name)
+        $html = $this->replaceFunctionCalls($html, $data);
+
+        // 1. Methoden-Aufrufe: $user->getName(), $date->format('Y-m-d')
+        $html = $this->replaceMethodCalls($html, $data);
+
+
+
+        // 3. Objekt-Properties: $error->name
+        $html = $this->replaceObjectProperties($html, $data);
+
+        // 4. Array-Zugriffe: $data['key']
+        $html = $this->replaceArrayAccess($html, $data);
+
+        // 5. Einfache Variablen: $name
+        $html = $this->replaceSimpleVariables($html, $data);
+
+        // 6. Ternäre Operatoren: $condition ? 'true' : 'false'
+        $html = $this->replaceTernaryOperators($html, $data);
+
+        return $html;
+    }
+
+    /**
+     * Ersetzt Methoden-Aufrufe: $user->getName(), $date->format('Y-m-d')
+     */
+    private function replaceMethodCalls(string $html, array $data): string
+    {
+        #debug(html_entity_decode($html));
+
+        return preg_replace_callback(
+            '/\$([a-zA-Z_][a-zA-Z0-9_]*)((?:->|(?:-&gt;))[a-zA-Z_][a-zA-Z0-9_]*)*(?:->|(?:-&gt;))([a-zA-Z_][a-zA-Z0-9_]*)\(([^)]*)\)/',
+            function($matches) use ($data) {
+                $varName = $matches[1];
+                $propertyChain = $matches[2] ? str_replace('-&gt;', '->', $matches[2]) : '';
+                $methodName = $matches[3];
+                $argsString = $matches[4];
+
+                if (!array_key_exists($varName, $data)) {
+                    return $matches[0];
+                }
+
+                $object = $data[$varName];
+
+                // Property-Chain navigieren falls vorhanden
+                if (!empty($propertyChain)) {
+                    $properties = explode('->', trim($propertyChain, '->'));
+                    foreach ($properties as $property) {
+                        if (is_object($object) && property_exists($object, $property)) {
+                            $object = $object->$property;
+                        } else {
+                            return $matches[0];
+                        }
+                    }
+                }
+
+                if (!is_object($object)) {
+                    return $matches[0];
+                }
+
+                // Methode ausführen
+                try {
+                    $args = $this->parseArguments($argsString, $data);
+
+                    if (method_exists($object, $methodName)) {
+                        $result = $object->$methodName(...$args);
+                        return $this->formatValue($result);
+                    }
+
+                    // Getter-Fallback: getName() -> name Property
+                    if (str_starts_with($methodName, 'get') && empty($args)) {
+                        $propertyName = lcfirst(substr($methodName, 3));
+                        if (property_exists($object, $propertyName)) {
+                            return $this->formatValue($object->$propertyName);
+                        }
+                    }
+
+                } catch (\Throwable $e) {
+                    // Fehler ignorieren, Original-String zurückgeben
+                    return $matches[0];
+                }
+
+                return $matches[0];
+            },
+            $html
+        );
+    }
+
+    /**
+     * Ersetzt Funktions-Aufrufe: date('Y-m-d'), strtoupper($name)
+     */
+    private function replaceFunctionCalls(string $html, array $data): string
+    {
+        // Verbesserte Regex, die sowohl -> als auch HTML-kodiertes -&gt; erkennt
+        return preg_replace_callback(
+            '/\b([a-zA-Z_][a-zA-Z0-9_]*)\(([^)]*)\)/',
+            function($matches) use ($data) {
+                $functionName = $matches[1];
+                $argsString = $matches[2];
+
+                // Nur erlaubte Funktionen ausführen
+                if (!in_array($functionName, $this->allowedFunctions)) {
+                    return $matches[0];
+                }
+
+                try {
+                    $args = $this->parseArguments($argsString, $data);
+
+                    // Custom Template-Funktionen
+                    if (method_exists($this, 'function_' . $functionName)) {
+                        $result = $this->{'function_' . $functionName}(...$args);
+                        return $this->formatValue($result);
+                    }
+
+                    // Standard PHP-Funktionen
+                    if (function_exists($functionName)) {
+                        $result = $functionName(...$args);
+                        return $this->formatValue($result);
+                    }
+
+                } catch (\Throwable $e) {
+                    return $matches[0];
+                }
+
+                return $matches[0];
+            },
+            $html
+        );
+    }
+
+    /**
+     * Ersetzt Objekt-Properties: $error->name
+     */
+    private function replaceObjectProperties(string $html, array $data): string
+    {
+        // Verbesserte Regex, die sowohl -> als auch HTML-kodiertes -&gt; erkennt
+        return preg_replace_callback(
+            '/\$([a-zA-Z_][a-zA-Z0-9_]*)((?:->|(?:-&gt;))[a-zA-Z_][a-zA-Z0-9_]*)+/',
+            function($matches) use ($data) {
+                $varName = $matches[1];
+                $propertyChain = str_replace('-&gt;', '->', $matches[2]);
+
+                if (!array_key_exists($varName, $data)) {
+                    return $matches[0]; // Variable nicht gefunden
+                }
+
+                $value = $data[$varName];
+
+                // Property-Chain abarbeiten: ->name->email
+                $properties = explode('->', trim($propertyChain, '->'));
+
+                foreach ($properties as $property) {
+                    if (is_object($value)) {
+                        if (property_exists($value, $property)) {
+                            $value = $value->$property;
+                        } elseif (method_exists($value, '__get')) {
+                            $value = $value->__get($property);
+                        } else {
+                            return $matches[0]; // Property nicht gefunden
+                        }
+                    } elseif (is_array($value)) {
+                        if (array_key_exists($property, $value)) {
+                            $value = $value[$property];
+                        } else {
+                            return $matches[0]; // Key nicht gefunden
+                        }
+                    } else {
+                        return $matches[0]; // Kann nicht weiter navigieren
+                    }
+                }
+
+                return $this->formatValue($value);
+            },
+            $html
+        );
+    }
+
+    /**
+     * Ersetzt Array-Zugriffe: $data['key'], $items[0]
+     */
+    private function replaceArrayAccess(string $html, array $data): string
+    {
+        return preg_replace_callback(
+            "/\\$([a-zA-Z_][a-zA-Z0-9_]*)\[(['\"]?)([^'\"\]]+)\2\]/",
+            function($matches) use ($data) {
+                $varName = $matches[1];
+                $key = $matches[3];
+
+                if (!array_key_exists($varName, $data)) {
+                    return $matches[0];
+                }
+
+                $array = $data[$varName];
+
+                if (is_array($array)) {
+                    // Numerischer oder String-Key
+                    $actualKey = is_numeric($key) ? (int)$key : $key;
+
+                    if (array_key_exists($actualKey, $array)) {
+                        return $this->formatValue($array[$actualKey]);
+                    }
+                } elseif (is_object($array)) {
+                    // Objekt wie Array behandeln
+                    if (property_exists($array, $key)) {
+                        return $this->formatValue($array->$key);
+                    }
+                }
+
+                return $matches[0];
+            },
+            $html
+        );
+    }
+
+    /**
+     * Ersetzt einfache Variablen: $name
+     */
+    private function replaceSimpleVariables(string $html, array $data): string
+    {
+        return preg_replace_callback(
+            '/\$([a-zA-Z_][a-zA-Z0-9_]*)(?![a-zA-Z0-9_\[\-])/',
+            function($matches) use ($data) {
+                $varName = $matches[1];
+
+                if (array_key_exists($varName, $data)) {
+                    return $this->formatValue($data[$varName]);
+                }
+
+                return $matches[0]; // Variable nicht gefunden
+            },
+            $html
+        );
+    }
+
+    /**
+     * Parst Argument-String zu Array von Werten
+     */
+    private function parseArguments(string $argsString, array $data): array
+    {
+        if (trim($argsString) === '') {
+            return [];
+        }
+
+        $args = [];
+        $parts = $this->splitArguments($argsString);
+
+        foreach ($parts as $part) {
+            $part = trim($part);
+
+            // String-Literale: 'text' oder "text"
+            if (preg_match('/^[\'"](.*)[\'"]$/s', $part, $matches)) {
+                $args[] = $matches[1];
+                continue;
+            }
+
+            // Zahlen
+            if (is_numeric($part)) {
+                $args[] = str_contains($part, '.') ? (float)$part : (int)$part;
+                continue;
+            }
+
+            // Boolean
+            if ($part === 'true') {
+                $args[] = true;
+                continue;
+            }
+            if ($part === 'false') {
+                $args[] = false;
+                continue;
+            }
+
+            // Null
+            if ($part === 'null') {
+                $args[] = null;
+                continue;
+            }
+
+            // Variablen: $name
+            if (preg_match('/^\$([a-zA-Z_][a-zA-Z0-9_]*)$/', $part, $matches)) {
+                $varName = $matches[1];
+                if (array_key_exists($varName, $data)) {
+                    $args[] = $data[$varName];
+                    continue;
+                }
+            }
+
+            // Fallback: als String behandeln
+            $args[] = $part;
+        }
+
+        return $args;
+    }
+
+    /**
+     * Teilt Argument-String intelligent auf (berücksichtigt Quotes)
+     */
+    private function splitArguments(string $argsString): array
+    {
+        $args = [];
+        $current = '';
+        $inQuotes = false;
+        $quoteChar = null;
+        $length = strlen($argsString);
+
+        for ($i = 0; $i < $length; $i++) {
+            $char = $argsString[$i];
+
+            if (!$inQuotes && ($char === '"' || $char === "'")) {
+                $inQuotes = true;
+                $quoteChar = $char;
+                $current .= $char;
+            } elseif ($inQuotes && $char === $quoteChar) {
+                $inQuotes = false;
+                $quoteChar = null;
+                $current .= $char;
+            } elseif (!$inQuotes && $char === ',') {
+                $args[] = trim($current);
+                $current = '';
+            } else {
+                $current .= $char;
+            }
+        }
+
+        if ($current !== '') {
+            $args[] = trim($current);
+        }
+
+        return $args;
+    }
+
+    /**
+     * Formatiert einen Wert für die HTML-Ausgabe
+     */
+    private function formatValue(mixed $value): string
+    {
+        return match (true) {
+            is_null($value) => '',
+            is_bool($value) => $value ? '1' : '0',
+            is_scalar($value) => htmlspecialchars((string) $value, ENT_QUOTES, 'UTF-8'),
+            is_array($value) => htmlspecialchars(json_encode($value, JSON_UNESCAPED_UNICODE), ENT_QUOTES, 'UTF-8'),
+            is_object($value) => $this->formatObject($value),
+            default => htmlspecialchars((string) $value, ENT_QUOTES, 'UTF-8')
+        };
+    }
+
+    /**
+     * Formatiert Objekte für die Ausgabe
+     */
+    private function formatObject(object $value): string
+    {
+        if (method_exists($value, '__toString')) {
+            return htmlspecialchars((string) $value, ENT_QUOTES, 'UTF-8');
+        }
+
+        if (method_exists($value, 'toArray')) {
+            return htmlspecialchars(json_encode($value->toArray(), JSON_UNESCAPED_UNICODE), ENT_QUOTES, 'UTF-8');
+        }
+
+        return htmlspecialchars(get_class($value), ENT_QUOTES, 'UTF-8');
+    }
+
+    // Custom Template-Funktionen
+
+    private function function_format_date(string|\DateTime $date, string $format = 'Y-m-d H:i:s'): string
+    {
+        if (is_string($date)) {
+            $date = new \DateTime($date);
+        }
+        return $date->format($format);
+    }
+
+    private function function_format_currency(float $amount, string $currency = 'EUR'): string
+    {
+        return number_format($amount, 2, ',', '.') . ' ' . $currency;
+    }
+
+    private function function_format_filesize(int $bytes): string
+    {
+        $units = ['B', 'KB', 'MB', 'GB', 'TB'];
+        $factor = floor((strlen((string)$bytes) - 1) / 3);
+        return sprintf("%.1f %s", $bytes / pow(1024, $factor), $units[$factor]);
+    }
+
+    private function replaceTernaryOperators(string $html, array $data): string
+    {
+        return $html;
+    }
+}
diff --git a/src/Framework/View/Processors/PlaceholderReplacer.php b/src/Framework/View/Processors/PlaceholderReplacer.php
index 19f93506..fe2cf383 100644
--- a/src/Framework/View/Processors/PlaceholderReplacer.php
+++ b/src/Framework/View/Processors/PlaceholderReplacer.php
@@ -2,41 +2,284 @@
 
 namespace App\Framework\View\Processors;
 
-use App\Framework\View\DomProcessor;
+use App\Framework\DI\Container;
+use App\Framework\View\Functions\ImageSlotFunction;
+use App\Framework\View\Functions\UrlFunction;
 use App\Framework\View\RenderContext;
+use App\Framework\View\StringProcessor;
+use App\Framework\View\TemplateFunctions;
+use DateTimeZone;
 
-final readonly class PlaceholderReplacer implements DomProcessor
+final class PlaceholderReplacer implements StringProcessor
 {
-
-    public function process(\DOMDocument $dom, RenderContext $context): void
+    public function __construct(
+        private Container $container,
+    )
     {
-        $xpath = new \DOMXPath($dom);
-        foreach ($xpath->query('//text()') as $textNode) {
-            $textNode->nodeValue = preg_replace_callback(
-                '/{{\s*([\w.]+)\s*}}/',
-                fn($m) => $this->resolveValue($context->data, $m[1]),
-                $textNode->nodeValue
-            );
+    }
+
+    // Erlaubte Template-Funktionen für zusätzliche Sicherheit
+    private array $allowedTemplateFunctions = [
+        'date', 'format_date', 'format_currency', 'format_filesize',
+        'strtoupper', 'strtolower', 'ucfirst', 'trim', 'count', /*'imageslot'*/
+    ];
+
+    public function process(string $html, RenderContext $context): string
+    {
+        // Template-Funktionen: {{ date('Y-m-d') }}, {{ format_currency(100) }}
+        $html = $this->replaceTemplateFunctions($html, $context);
+
+        // Standard Variablen und Methoden: {{ item.getRelativeFile() }}
+        return preg_replace_callback(
+            '/{{\\s*([\\w.]+)(?:\\(\\s*([^)]*)\\s*\\))?\\s*}}/',
+            function($matches) use ($context) {
+                $expression = $matches[1];
+                $params = isset($matches[2]) ? trim($matches[2]) : null;
+
+                if ($params !== null) {
+                    return $this->resolveMethodCall($context->data, $expression, $params);
+                } else {
+                    return $this->resolveEscaped($context->data, $expression, ENT_QUOTES | ENT_HTML5);
+                }
+            },
+            $html
+        );
+    }
+
+    private function replaceTemplateFunctions(string $html, RenderContext $context): string
+    {
+        return preg_replace_callback(
+            '/{{\\s*([a-zA-Z_][a-zA-Z0-9_]*)\\(([^)]*)\\)\\s*}}/',
+            function($matches) use ($context) {
+                $functionName = $matches[1];
+                $params = trim($matches[2]);
+
+                $functions = new TemplateFunctions($this->container, ImageSlotFunction::class, UrlFunction::class);
+                if($functions->has($functionName)) {
+                    $function = $functions->get($functionName);
+                    $args = $this->parseParams($params, $context->data);
+                    if(is_callable($function)) {
+                        return $function(...$args);
+                    }
+                    #return $function(...$args);
+                }
+
+                // Nur erlaubte Funktionen
+                if (!in_array($functionName, $this->allowedTemplateFunctions)) {
+                    return $matches[0];
+                }
+
+                try {
+                    $args = $this->parseParams($params, $context->data);
+
+                    // Custom Template-Funktionen
+                    if (method_exists($this, 'function_' . $functionName)) {
+                        $result = $this->{'function_' . $functionName}(...$args);
+                        return $result;
+                        #return htmlspecialchars((string)$result, ENT_QUOTES | ENT_HTML5, 'UTF-8');
+                    }
+
+                    // Standard PHP-Funktionen (begrenzt)
+                    if (function_exists($functionName)) {
+                        $result = $functionName(...$args);
+                        return htmlspecialchars((string)$result, ENT_QUOTES | ENT_HTML5, 'UTF-8');
+                    }
+
+                } catch (\Throwable $e) {
+                    return $matches[0];
+                }
+
+                return $matches[0];
+            },
+            $html
+        );
+    }
+
+    private function function_imageslot(string $slotName): string
+    {
+        $function = $this->container->get(ImageSlotFunction::class);
+        return ($function('slot1'));
+    }
+
+    // Custom Template-Funktionen
+    private function function_format_date(string|\DateTime $date, string $format = 'Y-m-d H:i:s'): string
+    {
+        if (is_string($date)) {
+            $date = new \DateTimeImmutable($date, new DateTimeZone('Europe/Berlin'));
+        }
+        return $date->format($format);
+    }
+
+    private function function_format_currency(float $amount, string $currency = 'EUR'): string
+    {
+        return number_format($amount, 2, ',', '.') . ' ' . $currency;
+    }
+
+    private function function_format_filesize(int $bytes): string
+    {
+        $units = ['B', 'KB', 'MB', 'GB', 'TB'];
+        $factor = floor((strlen((string)$bytes) - 1) / 3);
+        return sprintf("%.1f %s", $bytes / pow(1024, $factor), $units[$factor]);
+    }
+
+    private function resolveMethodCall(array $data, string $expression, string $params): string
+    {
+        $parts = explode('.', $expression);
+        $methodName = array_pop($parts); // Letzter Teil ist der Methodenname
+        $objectPath = implode('.', $parts); // Pfad zum Objekt
+
+        // Objekt auflösen
+        $object = $this->resolveValue($data, $objectPath);
+
+        if (!is_object($object)) {
+            return '{{ ' . $expression . '() }}'; // Platzhalter beibehalten
+        }
+
+        if (!method_exists($object, $methodName)) {
+            return '{{ ' . $expression . '() }}'; // Platzhalter beibehalten
+        }
+
+        try {
+            // Parameter parsen (falls vorhanden)
+            $parsedParams = empty($params) ? [] : $this->parseParams($params, $data);
+
+            // Methode aufrufen
+            $result = $object->$methodName(...$parsedParams);
+
+            return htmlspecialchars((string)$result, ENT_QUOTES | ENT_HTML5, 'UTF-8');
+        } catch (\Throwable $e) {
+            // Bei Fehlern Platzhalter beibehalten
+            return '{{ ' . $expression . '() }}';
         }
     }
 
-    private function resolveValue(array $data, string $expr): string
+    private function resolveEscaped(array $data, string $expr, int $flags): string
+    {
+        $value = $this->resolveValue($data, $expr);
+        if ($value === null) {
+            // Bleibt als Platzhalter stehen
+            return '{{ ' . $expr . ' }}';
+        }
+        return htmlspecialchars((string)$value, $flags, 'UTF-8');
+    }
+
+    private function resolveValue(array $data, string $expr): mixed
     {
         $keys = explode('.', $expr);
         $value = $data;
+
         foreach ($keys as $key) {
-            if (!is_array($value) || !array_key_exists($key, $value)) {
-                return "{{ $expr }}"; // Platzhalter bleibt erhalten
+            if (is_array($value) && array_key_exists($key, $value)) {
+                $value = $value[$key];
+            } elseif (is_object($value) && isset($value->$key)) {
+                $value = $value->$key;
+            } else {
+                return null;
             }
-            $value = $value[$key];
         }
-        return is_scalar($value) ? (string)$value : '';
+
+        return $value;
     }
 
-    public function supports(\DOMElement $element): bool
+    /**
+     * Parst Parameter aus einem Parameter-String
+     */
+    private function parseParams(string $paramsString, array $data): array
     {
-        return $element->tagName === 'text';
+        if (empty(trim($paramsString))) {
+            return [];
+        }
 
+        $params = [];
+        $parts = $this->splitParams($paramsString);
+
+        foreach ($parts as $part) {
+            $part = trim($part);
+
+            // String-Literale: 'text' oder "text"
+            if (preg_match('/^[\'\"](.*)[\'\"]/s', $part, $matches)) {
+                $params[] = $matches[1];
+                continue;
+            }
+
+            // Zahlen
+            if (is_numeric($part)) {
+                $params[] = str_contains($part, '.') ? (float)$part : (int)$part;
+                continue;
+            }
+
+            // Boolean
+            if ($part === 'true') {
+                $params[] = true;
+                continue;
+            }
+            if ($part === 'false') {
+                $params[] = false;
+                continue;
+            }
+
+            // Null
+            if ($part === 'null') {
+                $params[] = null;
+                continue;
+            }
+
+            // Variablen-Referenzen: $variable oder Pfade: objekt.eigenschaft
+            if (str_starts_with($part, '$')) {
+                $varName = substr($part, 1);
+                if (array_key_exists($varName, $data)) {
+                    $params[] = $data[$varName];
+                    continue;
+                }
+            } elseif (str_contains($part, '.')) {
+                $value = $this->resolveValue($data, $part);
+                if ($value !== null) {
+                    $params[] = $value;
+                    continue;
+                }
+            }
+
+            // Fallback: Als String behandeln
+            $params[] = $part;
+        }
+
+        return $params;
     }
 
+    /**
+     * Teilt einen Parameter-String in einzelne Parameter auf
+     */
+    private function splitParams(string $paramsString): array
+    {
+        $params = [];
+        $current = '';
+        $inQuotes = false;
+        $quoteChar = null;
+        $length = strlen($paramsString);
+
+        for ($i = 0;  $i < $length; $i++) {
+            $char = $paramsString[$i];
+
+            if (!$inQuotes && ($char === '"' || $char === "'")) {
+                $inQuotes = true;
+                $quoteChar = $char;
+                $current .= $char;
+            } elseif ($inQuotes && $char === $quoteChar) {
+                $inQuotes = false;
+                $quoteChar = null;
+                $current .= $char;
+            } elseif (!$inQuotes && $char === ',') {
+                $params[] = trim($current);
+                $current = '';
+            } else {
+                $current .= $char;
+            }
+        }
+
+        if ($current !== '') {
+            $params[] = trim($current);
+        }
+
+        return $params;
+    }
 }
diff --git a/src/Framework/View/Processors/RemoveEmptyLinesProcessor.php b/src/Framework/View/Processors/RemoveEmptyLinesProcessor.php
new file mode 100644
index 00000000..e0f885fc
--- /dev/null
+++ b/src/Framework/View/Processors/RemoveEmptyLinesProcessor.php
@@ -0,0 +1,35 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\View\Processors;
+
+use App\Framework\View\DomProcessor;
+use App\Framework\View\DomWrapper;
+use App\Framework\View\RenderContext;
+use Dom\HTMLDocument;
+use Dom\Node;
+
+final class RemoveEmptyLinesProcessor implements DomProcessor
+{
+    public function process(DomWrapper $dom, RenderContext $context): DomWrapper
+    {
+        $this->removeEmptyTextNodes($dom->document);
+
+        return $dom;
+    }
+
+    private function removeEmptyTextNodes(Node $node): void
+    {
+        for ($i = $node->childNodes->length - 1; $i >= 0; $i--) {
+            $child = $node->childNodes->item($i);
+
+            // Wenn es ein Text-Node ist und nur aus Whitespace besteht
+            if ($child->nodeType === XML_TEXT_NODE && preg_match('/^\s*$/', $child->nodeValue)) {
+                $node->removeChild($child);
+            } elseif ($child->hasChildNodes()) {
+                // Rekursion in die Tiefe
+                $this->removeEmptyTextNodes($child);
+            }
+        }
+    }
+}
diff --git a/src/Framework/View/Processors/SingleLineHtmlProcessor.php b/src/Framework/View/Processors/SingleLineHtmlProcessor.php
new file mode 100644
index 00000000..c5aaf0c3
--- /dev/null
+++ b/src/Framework/View/Processors/SingleLineHtmlProcessor.php
@@ -0,0 +1,18 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\View\Processors;
+
+use App\Framework\View\RenderContext;
+use App\Framework\View\StringProcessor;
+
+final class SingleLineHtmlProcessor implements StringProcessor
+{
+    public function process(string $html, RenderContext $context): string
+    {
+        // Entfernt Zeilenumbrüche und doppelte Whitespaces, alles in eine Zeile
+        $html = preg_replace('/>(\s|\n|\r)+</', '><', $html);
+        $html = preg_replace('/\s+/', ' ', $html);
+        return trim($html);
+    }
+}
diff --git a/src/Framework/View/Processors/SlotProcessor.php b/src/Framework/View/Processors/SlotProcessor.php
index 03d487b8..fd3d662e 100644
--- a/src/Framework/View/Processors/SlotProcessor.php
+++ b/src/Framework/View/Processors/SlotProcessor.php
@@ -3,7 +3,9 @@
 namespace App\Framework\View\Processors;
 
 use App\Framework\View\DomProcessor;
+use App\Framework\View\DomWrapper;
 use App\Framework\View\RenderContext;
+use Dom\HTMLDocument;
 
 /*
 
@@ -17,11 +19,9 @@ use App\Framework\View\RenderContext;
 
 final readonly class SlotProcessor implements DomProcessor
 {
-    public function process(\DOMDocument $dom, RenderContext $context): void
+    public function process(DomWrapper $dom, RenderContext $context): DomWrapper
     {
-        $xpath = new \DOMXPath($dom);
-
-        foreach ($xpath->query('//slot[@name]') as $slotNode) {
+        foreach ($dom->querySelectorAll('slot[name]') as $slotNode) {
             $slotName = $slotNode->getAttribute('name');
             $html = $context->slots[$slotName] ?? null;
 
@@ -38,5 +38,7 @@ final readonly class SlotProcessor implements DomProcessor
 
             $slotNode->parentNode?->replaceChild($replacement, $slotNode);
         }
+
+        return $dom;
     }
 }
diff --git a/src/Framework/View/Processors/SwitchCaseProcessor.php b/src/Framework/View/Processors/SwitchCaseProcessor.php
index 8c1b408c..15ca71e6 100644
--- a/src/Framework/View/Processors/SwitchCaseProcessor.php
+++ b/src/Framework/View/Processors/SwitchCaseProcessor.php
@@ -3,8 +3,10 @@
 namespace App\Framework\View\Processors;
 
 use App\Framework\View\DomProcessor;
+use App\Framework\View\DomWrapper;
 use App\Framework\View\RenderContext;
-use DOMXPath;
+use Dom\Element;
+use Dom\HTMLDocument;
 
 # Ersetzt ein eigenes `<switch value="foo">` mit inneren `<case when="bar">`-Elementen.
 
@@ -14,11 +16,9 @@ final readonly class SwitchCaseProcessor implements DomProcessor
     /**
      * @inheritDoc
      */
-    public function process(\DOMDocument $dom, RenderContext $context): void
+    public function process(DomWrapper $dom, RenderContext $context): DomWrapper
     {
-        $xpath = new DOMXPath($dom);
-
-        foreach ($xpath->query('//switch[@value]') as $switchNode) {
+        foreach ($dom->querySelectorAll('switch[value]') as $switchNode) {
             $key = $switchNode->getAttribute('value');
             $value = $context->data[$key] ?? null;
 
@@ -26,7 +26,7 @@ final readonly class SwitchCaseProcessor implements DomProcessor
             $defaultCase = null;
 
             foreach ($switchNode->childNodes as $child) {
-                if (!($child instanceof \DOMElement)) {
+                if (!($child instanceof Element)) {
                     continue;
                 }
 
@@ -57,5 +57,7 @@ final readonly class SwitchCaseProcessor implements DomProcessor
 
             $switchNode->parentNode?->replaceChild($replacement, $switchNode);
         }
+
+        return $dom;
     }
 }
diff --git a/src/Framework/View/Processors/VoidElementsSelfClosingProcessor.php b/src/Framework/View/Processors/VoidElementsSelfClosingProcessor.php
new file mode 100644
index 00000000..e242edf6
--- /dev/null
+++ b/src/Framework/View/Processors/VoidElementsSelfClosingProcessor.php
@@ -0,0 +1,27 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\View\Processors;
+
+use App\Framework\View\RenderContext;
+use App\Framework\View\StringProcessor;
+
+final class VoidElementsSelfClosingProcessor implements StringProcessor
+{
+    // Liste der HTML5-Void-Elemente
+    private const array VOID_ELEMENTS = [
+        'area', 'base', 'br', 'col', 'embed', 'hr', 'img',
+        'input', 'link', 'meta', 'source', 'track', 'wbr',
+    ];
+
+    public function process(string $html, RenderContext $context): string
+    {
+        $pattern = '#<(' . implode('|', self::VOID_ELEMENTS) . ')(\s[^>/]*)?(?<!/)>#i';
+
+        return preg_replace_callback($pattern, function($m) {
+            $tag = $m[1];
+            $attrs = $m[2] ?? '';
+            return "<$tag$attrs />";
+        }, $html);
+    }
+}
diff --git a/src/Framework/View/Processors/docs/AssetInjector.md b/src/Framework/View/Processors/docs/AssetInjector.md
new file mode 100644
index 00000000..10899e62
--- /dev/null
+++ b/src/Framework/View/Processors/docs/AssetInjector.md
@@ -0,0 +1,62 @@
+# AssetInjector
+
+## Überblick
+
+Der `AssetInjector` ist ein Prozessor, der JavaScript- und CSS-Assets aus einem Vite-Manifest automatisch in HTML-Dokumente einfügt.
+
+## Funktionsweise
+
+- Liest das Vite-Manifest (JSON) für JS/CSS-Dateien
+- Fügt die entsprechenden `<script>` und `<link>` Tags ins `<head>` oder `<body>` ein
+- Unterstützt Vite's Hot Module Replacement (HMR) im Entwicklungsmodus
+
+## Konfiguration
+
+Der AssetInjector benötigt den Pfad zum Vite-Manifest:
+
+```php
+$assetInjector = new AssetInjector('/path/to/manifest.json');
+```
+
+## Manifest-Format
+
+Das Vite-Manifest hat üblicherweise folgendes Format:
+
+```json
+{
+  "resources/js/main.js": {
+    "file": "assets/main.1234abcd.js",
+    "css": ["assets/main.5678efgh.css"]
+  },
+  "resources/css/styles.css": {
+    "file": "assets/styles.5678efgh.css"
+  }
+}
+```
+
+## Implementierung
+
+Der Prozessor sucht nach dem `<head>` oder `<body>` Element und fügt die Asset-Tags ein. Er verarbeitet sowohl JavaScript-Dateien (als `<script>` Tags) als auch CSS-Dateien (als `<link>` Tags).
+
+## JavaScript-Integration
+
+JavaScript-Assets werden als Module geladen:
+
+```html
+<script src="/assets/main.1234abcd.js" type="module"></script>
+```
+
+## CSS-Integration
+
+CSS-Assets werden über Link-Tags eingebunden:
+
+```html
+<link rel="stylesheet" href="/assets/main.5678efgh.css">
+```
+
+## Vorteile
+
+- Automatische Versionierung von Assets (Cache-Busting)
+- Einfache Integration mit dem Vite-Build-System
+- Unterstützung für HMR im Entwicklungsmodus
+- Keine manuelle Verwaltung von Asset-URLs notwendig
diff --git a/src/Framework/View/Processors/docs/CommentStripProcessor.md b/src/Framework/View/Processors/docs/CommentStripProcessor.md
new file mode 100644
index 00000000..c034ad1e
--- /dev/null
+++ b/src/Framework/View/Processors/docs/CommentStripProcessor.md
@@ -0,0 +1,54 @@
+# CommentStripProcessor
+
+## Überblick
+
+Der `CommentStripProcessor` entfernt HTML-Kommentare aus der Ausgabe, um die Größe des resultierenden HTML zu reduzieren.
+
+## Funktionsweise
+
+- Findet alle HTML-Kommentare im DOM
+- Entfernt diese Kommentare aus dem Dokument
+- Behält optional spezielle Kommentare bei (z.B. für IE-Conditional-Comments)
+
+## Syntax
+
+Dieser Prozessor erfordert keine spezielle Syntax im Template. Er verarbeitet automatisch alle HTML-Kommentare:
+
+```html
+<!-- Dieser Kommentar wird entfernt -->
+<div>Sichtbarer Inhalt</div>
+<!--[if IE]>Dieser Kommentar könnte optional beibehalten werden<![endif]-->
+```
+
+## Implementierung
+
+Der Prozessor verwendet `xpath->query('//comment()')`, um alle Kommentarknoten im DOM zu finden. Diese werden dann aus ihren Elternknoten entfernt.
+
+## Konfigurationsoptionen
+
+- **keepConditionalComments**: (Boolean) Bei `true` werden IE-Conditional-Comments beibehalten
+- **keepSpecialComments**: (Boolean) Bei `true` werden Kommentare mit bestimmten Präfixen beibehalten (z.B. `<!--!` oder `<!--#`)
+
+## Beispiel für beizubehaltende Kommentare
+
+```html
+<!--! Dieser Kommentar würde beibehalten werden, wenn keepSpecialComments=true -->
+<!--[if IE]>Dieser Kommentar würde beibehalten werden, wenn keepConditionalComments=true<![endif]-->
+```
+
+## Vorteile
+
+- Reduziert die Größe der HTML-Ausgabe
+- Verbessert die Ladezeit
+- Entfernt Entwickler-Kommentare aus der Produktionsumgebung
+
+## Anwendungsfälle
+
+- Optimierung für Produktionsumgebungen
+- Reduzierung der Bandbreitennutzung
+- Entfernung von Entwicklerhinweisen und Debug-Informationen
+
+## Tipps
+
+- Verwenden Sie diesen Prozessor als einen der letzten Schritte in der Verarbeitungskette
+- Kombinieren Sie ihn mit anderen Optimierungsprozessoren wie `RemoveEmptyLinesProcessor` und `SingleLineHtmlProcessor` für maximale Komprimierung
diff --git a/src/Framework/View/Processors/docs/ComponentProcessor.md b/src/Framework/View/Processors/docs/ComponentProcessor.md
new file mode 100644
index 00000000..c2faefe2
--- /dev/null
+++ b/src/Framework/View/Processors/docs/ComponentProcessor.md
@@ -0,0 +1,55 @@
+# ComponentProcessor
+
+## Überblick
+
+Der `ComponentProcessor` ermöglicht die Verwendung von wiederverwendbaren UI-Komponenten in Templates.
+
+## Funktionsweise
+
+- Findet `<component>`-Tags im DOM
+- Rendert die benannte Komponente mit allen Attributen als Parameter
+- Ersetzt den Tag durch das gerenderte HTML der Komponente
+
+## Syntax
+
+```html
+<component name="komponentenName" attr1="wert1" attr2="wert2"></component>
+```
+
+## Beispiel
+
+```html
+<component name="card" title="Willkommen" image="/img/welcome.jpg">
+    <p>Dies ist eine Karte mit Inhalt</p>
+</component>
+```
+
+## Implementierung
+
+Der Prozessor verwendet den `ComponentRenderer`, um die angegebene Komponente zu rendern. Alle Attribute des `<component>`-Tags (außer `name`) werden als Parameter an den Renderer übergeben und mit den Daten aus dem RenderContext zusammengeführt.
+
+## Parameter
+
+- **name**: (Erforderlich) Der Name der zu rendernden Komponente
+- **Beliebige Attribute**: Werden als Parameter an die Komponente übergeben
+
+## Kombination mit Slots
+
+Der `ComponentProcessor` arbeitet gut mit dem `SlotProcessor` zusammen, um die Flexibilität von Komponenten zu erhöhen:
+
+```html
+<component name="modal" title="Bestätigung">
+    <div slot="header">Benutzerdefinierter Header</div>
+    <p>Hauptinhalt des Modals</p>
+    <div slot="footer">
+        <button>Bestätigen</button>
+        <button>Abbrechen</button>
+    </div>
+</component>
+```
+
+## Vorteile
+
+- Fördert die Wiederverwendung von UI-Elementen
+- Verbessert die Konsistenz in der gesamten Anwendung
+- Ermöglicht eine komponentenbasierte Entwicklung ähnlich wie in modernen Frontend-Frameworks
diff --git a/src/Framework/View/Processors/docs/DateFormatProcessor.md b/src/Framework/View/Processors/docs/DateFormatProcessor.md
new file mode 100644
index 00000000..b2f4d168
--- /dev/null
+++ b/src/Framework/View/Processors/docs/DateFormatProcessor.md
@@ -0,0 +1,65 @@
+# DateFormatProcessor
+
+## Überblick
+
+Der `DateFormatProcessor` formatiert Datums- und Zeitwerte in Templates mit benutzerdefinierten Formaten.
+
+## Funktionsweise
+
+- Findet Tags mit `date-format`-Attribut
+- Formatiert den Inhalt des Tags oder den angegebenen Wert nach dem gewünschten Format
+- Ersetzt den Inhalt des Tags mit dem formatierten Datum
+
+## Syntax
+
+```html
+<span date-format="format" [date-value="value"]>fallbackValue</span>
+```
+
+## Parameter
+
+- **date-format**: (Erforderlich) Das Format für die Datumsausgabe (PHP date()-Format)
+- **date-value**: (Optional) Der zu formatierende Wert, falls nicht angegeben wird der Inhalt des Tags verwendet
+
+## Beispiele
+
+```html
+<!-- Aktuelles Datum formatieren -->
+<span date-format="d.m.Y">Aktuelles Datum</span>
+
+<!-- Spezifischen Zeitstempel formatieren -->
+<span date-format="d.m.Y H:i" date-value="2023-12-31 23:59:59">31.12.2023</span>
+
+<!-- Variable aus dem RenderContext formatieren -->
+<span date-format="d.m.Y H:i" date-value="{{ createdAt }}">Erstelldatum</span>
+```
+
+## Unterstützte Eingabeformate
+
+Der Prozessor kann verschiedene Eingabeformate verarbeiten:
+
+- Unix-Zeitstempel (als Zahl)
+- ISO 8601 Datum-/Zeitstring (z.B. "2023-12-31T23:59:59")
+- Natürliche Sprachausdrücke (z.B. "next Monday")
+- DateTime-Objekte (wenn im RenderContext vorhanden)
+
+## Ausgabeformatierung
+
+Die Formatierung erfolgt mittels PHP's `date()`-Funktion. Die wichtigsten Formatierungszeichen sind:
+
+- **d**: Tag des Monats (01-31)
+- **m**: Monat (01-12)
+- **Y**: Jahr (vierstellig)
+- **H**: Stunde im 24-Stunden-Format (00-23)
+- **i**: Minuten (00-59)
+- **s**: Sekunden (00-59)
+
+## Localization
+
+Für eine lokalisierte Datumsausgabe kann der Prozessor mit der IntlDateFormatter-Klasse erweitert werden, um sprachspezifische Formatierungen zu unterstützen.
+
+## Tipps
+
+- Verwenden Sie für konsistente Datumsformatierung im gesamten Template
+- Kann mit dem PlaceholderReplacer kombiniert werden, um dynamische Datumswerte zu formatieren
+- Nützlich für Blogs, Ereignislisten und alle zeitbezogenen Darstellungen
diff --git a/src/Framework/View/Processors/docs/EscapeProcessor.md b/src/Framework/View/Processors/docs/EscapeProcessor.md
new file mode 100644
index 00000000..5389695b
--- /dev/null
+++ b/src/Framework/View/Processors/docs/EscapeProcessor.md
@@ -0,0 +1,55 @@
+# EscapeProcessor
+
+## Überblick
+
+Der `EscapeProcessor` ist ein String-Prozessor (im Gegensatz zu DOM-Prozessoren), der für das sichere Escaping von Variablen zum Schutz vor XSS-Angriffen zuständig ist.
+
+## Funktionsweise
+
+- Verarbeitet den HTML-String direkt (nicht das DOM)
+- Ersetzt `{{ ... }}` durch escaped HTML (mit htmlspecialchars)
+- Ersetzt `{{{ ... }}}` durch rohen HTML-Inhalt (ohne Escaping)
+
+## Syntax
+
+```
+{{ variable }}    // Mit Escaping (sicher)
+{{{ variable }}}  // Ohne Escaping (für vertrauenswürdigen HTML-Code)
+```
+
+## Beispiel
+
+```html
+<!-- Mit Escaping (sicher) -->
+<div class="user-info">
+    <h2>{{ username }}</h2>
+</div>
+
+<!-- Ohne Escaping (nur für vertrauenswürdigen HTML-Code) -->
+<div class="rich-content">
+    {{{ htmlContent }}}
+</div>
+```
+
+## Implementierung
+
+Der Prozessor verwendet reguläre Ausdrücke, um die Platzhalter zu finden und zu ersetzen:
+
+1. Zuerst werden die rohen Platzhalter (`{{{ ... }}}`) ohne Escaping ersetzt
+2. Dann werden die normalen Platzhalter (`{{ ... }}`) mit Escaping ersetzt
+
+## Sicherheitshinweise
+
+- Verwenden Sie `{{ ... }}` für alle Benutzerdaten oder nicht vertrauenswürdigen Inhalte
+- Verwenden Sie `{{{ ... }}}` nur für vertrauenswürdigen HTML-Code oder wenn HTML-Markup explizit erlaubt sein soll
+- Die Verwendung von `{{{ ... }}}` mit nicht vertrauenswürdigen Daten kann zu XSS-Sicherheitslücken führen
+
+## Besonderheiten
+
+Im Gegensatz zu den meisten anderen Prozessoren arbeitet der EscapeProcessor mit dem rohen HTML-String und nicht mit dem DOM. Dies ermöglicht das Ersetzen von Platzhaltern, bevor das HTML geparst wird.
+
+## Tipps
+
+- Verwenden Sie `{{ ... }}` als Standardmethode für die Ausgabe von Variablen
+- Verwenden Sie `{{{ ... }}}` nur, wenn Sie explizit HTML-Markup zulassen möchten (z.B. für Rich-Text-Editoren)
+- Dieser Prozessor kann vor der DOM-Verarbeitung verwendet werden, um Platzhalter in HTML-Attributen zu ersetzen
diff --git a/src/Framework/View/Processors/docs/ForProcessor.md b/src/Framework/View/Processors/docs/ForProcessor.md
new file mode 100644
index 00000000..53f87a1e
--- /dev/null
+++ b/src/Framework/View/Processors/docs/ForProcessor.md
@@ -0,0 +1,61 @@
+# ForProcessor
+
+## Überblick
+
+Der `ForProcessor` ermöglicht Iteration über Arrays oder Sammlungen und rendert HTML für jedes Element.
+
+## Funktionsweise
+
+- Findet `<for>`-Tags mit `var` und `in` Attributen
+- Durchläuft die angegebene Sammlung im RenderContext
+- Rendert den inneren Inhalt für jedes Element der Sammlung
+- Ersetzt Platzhalter mit den Werten des aktuellen Elements
+
+## Syntax
+
+```html
+<for var="itemName" in="arrayName">...</for>
+```
+
+## Beispiel
+
+```html
+<ul>
+    <for var="user" in="users">
+        <li>{{ user.name }} ({{ user.email }})</li>
+    </for>
+</ul>
+```
+
+## Implementierung
+
+Der Prozessor verwendet XPath, um `<for>`-Tags zu finden. Für jedes Element in der Sammlung wird der Inhalt des `<for>`-Tags geklont und die Platzhalter werden durch die entsprechenden Werte ersetzt. Die Ergebnisse werden zusammengefügt und an der Stelle des ursprünglichen `<for>`-Tags eingefügt.
+
+## Parameter
+
+- **var**: (Erforderlich) Der Name der Variable, die in jeder Iteration verwendet wird
+- **in**: (Erforderlich) Der Name des Arrays oder der Sammlung im RenderContext
+
+## Verschachtelte Schleifen
+
+Schleifen können verschachtelt werden, um mehrdimensionale Daten zu verarbeiten:
+
+```html
+<for var="category" in="categories">
+    <h2>{{ category.name }}</h2>
+    <ul>
+        <for var="product" in="category.products">
+            <li>{{ product.name }} - {{ product.price }}</li>
+        </for>
+    </ul>
+</for>
+```
+
+## Rekursive Platzhalterersetzung
+
+Der ForProcessor ersetzt Platzhalter rekursiv in allen Kind-Nodes des aktuellen Elements. Dies ermöglicht die Verwendung von Platzhaltern in verschachtelten Elementen und Attributen.
+
+## Tipps
+
+- Stellen Sie sicher, dass die im `in`-Attribut angegebene Variable ein Array oder eine iterable Collection ist
+- Der ForProcessor kann mit dem IfProcessor kombiniert werden, um bedingte Schleifen zu erstellen
diff --git a/src/Framework/View/Processors/docs/IfProcessor.md b/src/Framework/View/Processors/docs/IfProcessor.md
new file mode 100644
index 00000000..5321fa7c
--- /dev/null
+++ b/src/Framework/View/Processors/docs/IfProcessor.md
@@ -0,0 +1,50 @@
+# IfProcessor
+
+## Überblick
+
+Der `IfProcessor` ermöglicht die bedingte Darstellung von Elementen in Templates basierend auf Werten aus dem RenderContext.
+
+## Funktionsweise
+
+- Findet Elemente mit einem `if`-Attribut
+- Prüft den Wert der angegebenen Bedingung im RenderContext
+- Entfernt das Element, wenn die Bedingung nicht erfüllt ist ("falsy")
+- Entfernt nur das `if`-Attribut, wenn die Bedingung erfüllt ist ("truthy")
+
+## Syntax
+
+```html
+<div if="bedingung">...</div>
+```
+
+## Beispiel
+
+```html
+<div if="isLoggedIn" class="user-panel">
+    Benutzerbereich
+</div>
+
+<button if="!isLoggedIn" class="login-button">Anmelden</button>
+```
+
+## Implementierung
+
+Der Prozessor verwendet `querySelectorAll('*[if]')`, um alle Elemente mit einem `if`-Attribut zu finden. Der Wert des Attributs wird als Schlüssel im RenderContext verwendet. Die Methode `isTruthy()` bestimmt, ob der Wert als wahr angesehen wird.
+
+## Wahrheitswerte (Truthy/Falsy)
+
+Die folgende Logik wird verwendet, um zu bestimmen, ob ein Wert "truthy" ist:
+
+- Boolean `true`: Truthy
+- Boolean `false`: Falsy
+- `null`: Falsy
+- Leerer String oder nur Leerzeichen: Falsy
+- Numerischer Wert `0`: Falsy
+- Leeres Array: Falsy
+- Alle anderen Werte: Truthy
+
+## Tipps
+
+- Das `if`-Attribut kann an jedem beliebigen HTML-Element verwendet werden
+- Bei Erfüllung der Bedingung bleibt das Element erhalten, nur das `if`-Attribut wird entfernt
+- Für komplexere Bedingungen können vordefinierte Variablen im RenderContext verwendet werden
diff --git a/src/Framework/View/Processors/docs/IncludeProcessor.md b/src/Framework/View/Processors/docs/IncludeProcessor.md
new file mode 100644
index 00000000..8092e70b
--- /dev/null
+++ b/src/Framework/View/Processors/docs/IncludeProcessor.md
@@ -0,0 +1,48 @@
+# IncludeProcessor
+
+## Überblick
+
+Der `IncludeProcessor` ermöglicht das Einbinden externer HTML-Dateien in das aktuelle Template.
+
+## Funktionsweise
+
+- Findet alle `<include>`-Tags im DOM
+- Lädt die referenzierte Datei über den TemplateLoader
+- Fügt den Inhalt an der Stelle des `<include>`-Tags ein
+- Bei Fehlern wird ein HTML-Kommentar mit der Fehlermeldung eingefügt
+
+## Syntax
+
+```html
+<include file="pfad/zur/datei.html"></include>
+```
+
+## Beispiel
+
+```html
+<div class="main-content">
+    <include file="partials/header.html"></include>
+
+    <p>Seiteninhalt...</p>
+
+    <include file="partials/footer.html"></include>
+</div>
+```
+
+## Implementierung
+
+Der Prozessor verwendet den `TemplateLoader`, um die angegebene Datei zu laden und dann den `DomTemplateParser`, um das geladene HTML zu parsen. Anschließend wird der Inhalt als DocumentFragment in das aktuelle DOM eingefügt.
+
+## Fehlerbehandlung
+
+Wenn die angegebene Datei nicht gefunden wird oder andere Fehler auftreten, wird der `<include>`-Tag durch einen HTML-Kommentar mit der Fehlermeldung ersetzt:
+
+```html
+<!-- Fehler beim Laden von 'pfad/zur/datei.html': File not found -->
+```
+
+## Vorteile
+
+- Fördert die Wiederverwendung von Code
+- Ermöglicht die Aufteilung komplexer Templates in kleinere, wartbare Teile
+- Unterstützt modulare Entwicklung
diff --git a/src/Framework/View/Processors/docs/LayoutTagProcessor.md b/src/Framework/View/Processors/docs/LayoutTagProcessor.md
new file mode 100644
index 00000000..baf1b69b
--- /dev/null
+++ b/src/Framework/View/Processors/docs/LayoutTagProcessor.md
@@ -0,0 +1,59 @@
+# LayoutTagProcessor
+
+## Überblick
+
+Der `LayoutTagProcessor` implementiert ein Layout-System mit übergeordneten Templates, das die Strukturierung und Wiederverwendung von Seitenlayouts ermöglicht.
+
+## Funktionsweise
+
+- Findet `<layout>`-Tags im DOM
+- Lädt das angegebene Layout aus dem Verzeichnis `/src/Framework/View/templates/layouts/`
+- Platziert den Inhalt des aktuellen Templates im `<main>`-Tag des Layouts
+- Das Layout wird die übergeordnete Struktur für das gesamte Dokument
+
+## Syntax
+
+```html
+<layout src="layout-name"></layout>
+```
+
+## Beispiel
+
+**layout.view.php:**
+```html
+<!DOCTYPE html>
+<html>
+<head>
+    <title>Meine Webseite</title>
+</head>
+<body>
+    <header>...</header>
+    <main><!-- Hier wird der Inhalt eingefügt --></main>
+    <footer>...</footer>
+</body>
+</html>
+```
+
+**template.view.php:**
+```html
+<layout src="layout">
+    <h1>Mein Inhalt</h1>
+    <p>Wird in das main-Element des Layouts eingefügt</p>
+</layout>
+```
+
+## Implementierung
+
+Der Prozessor verwendet den `PathProvider` und `TemplateLoader`, um das Layout zu laden. Es sucht nach einem `<main>`-Element im Layout und ersetzt dessen Inhalt mit dem Inhalt des aktuellen Templates. Anschließend wird das gesamte DOM durch das neue Layout-DOM ersetzt.
+
+## Besonderheiten
+
+- Layouts müssen ein `<main>`-Element enthalten, um den Seiteninhalt aufzunehmen
+- Es wird nur der erste `<layout>`-Tag im Dokument verarbeitet
+- Die Layouts werden aus einem festen Verzeichnis geladen: `/src/Framework/View/templates/layouts/`
+
+## Tipps
+
+- Layouts können verschachtelt werden
+- Dies ist ideal für die Erstellung einer konsistenten Seitenstruktur in der gesamten Anwendung
+- Kombiniert gut mit dem `IncludeProcessor` für modulare Teile innerhalb des Layouts
diff --git a/src/Framework/View/Processors/docs/MetaManipulator.md b/src/Framework/View/Processors/docs/MetaManipulator.md
new file mode 100644
index 00000000..fd405ab0
--- /dev/null
+++ b/src/Framework/View/Processors/docs/MetaManipulator.md
@@ -0,0 +1,53 @@
+# MetaManipulator
+
+## Überblick
+
+Der `MetaManipulator` extrahiert Metadaten aus `<meta>`-Tags und macht sie für Templates verfügbar.
+
+## Funktionsweise
+
+- Findet alle `<meta name="x" content="y">`-Tags im DOM
+- Fügt deren Werte dem RenderContext hinzu (falls noch nicht vorhanden)
+- Ermöglicht Zugriff auf Metadaten über `{{ metaName }}` in Templates
+
+## Syntax
+
+```html
+<meta name="variableName" content="variableValue">
+```
+
+## Beispiel
+
+**Meta-Tags im HTML:**
+```html
+<head>
+    <meta name="description" content="Eine tolle Webseite">
+    <meta name="keywords" content="php, html, templates">
+</head>
+```
+
+**Zugriff im Template:**
+```html
+<h1>{{ title }}</h1>
+<p>{{ description }}</p>
+```
+
+## Implementierung
+
+Der Prozessor verwendet `querySelectorAll('meta[name][content]')`, um alle Meta-Tags mit den erforderlichen Attributen zu finden. Die Werte werden nur dann dem RenderContext hinzugefügt, wenn sie dort noch nicht existieren, um vorhandene Werte nicht zu überschreiben.
+
+## Verwendungszwecke
+
+- SEO-Metadaten im gesamten Template verfügbar machen
+- Seitentitel und Beschreibungen zentral definieren
+- Dynamische Meta-Tags für Social Media (OpenGraph, Twitter Cards)
+
+## Priorität
+
+Bereits im RenderContext vorhandene Werte haben Vorrang vor den Werten aus Meta-Tags. Dies ermöglicht das Überschreiben von Standard-Metadaten mit dynamischen Werten.
+
+## Tipps
+
+- Verwenden Sie diesen Prozessor, um gemeinsame Metadaten an einer zentralen Stelle zu definieren
+- Kombinieren Sie ihn mit dem LayoutTagProcessor, um seitenspezifische Meta-Tags in übergeordnete Layouts zu integrieren
+- Nützlich für dynamische Titel und Beschreibungen in sozialen Medien
diff --git a/src/Framework/View/Processors/docs/PlaceholderReplacer.md b/src/Framework/View/Processors/docs/PlaceholderReplacer.md
new file mode 100644
index 00000000..58ab9f15
--- /dev/null
+++ b/src/Framework/View/Processors/docs/PlaceholderReplacer.md
@@ -0,0 +1,36 @@
+# PlaceholderReplacer
+
+## Überblick
+
+Der `PlaceholderReplacer` ist ein zentraler Prozessor, der für das Ersetzen von Platzhaltern im Text und in Attributen zuständig ist.
+
+## Funktionsweise
+
+- Durchsucht alle Textknoten und Attribute nach `{{ ... }}`-Mustern
+- Ersetzt diese mit Werten aus dem RenderContext
+- Wandelt HTML-Entitäten um für sicheres Output
+
+## Syntax
+
+```php
+{{ variableName }}
+```
+
+## Beispiel
+
+```html
+<div class="user-info">
+    <h2>{{ username }}</h2>
+    <a href="{{ profileUrl }}">Profil ansehen</a>
+</div>
+```
+
+## Implementierung
+
+Der Prozessor verwendet reguläre Ausdrücke, um Platzhalter zu finden und zu ersetzen. Bei Attributen werden Anführungszeichen und andere spezielle Zeichen entsprechend maskiert.
+
+## Tipps
+
+- Für komplexe Pfade kann Punktnotation verwendet werden: `{{ user.profile.name }}`
+- Die Ersetzung ist standardmäßig escaped, um XSS-Angriffe zu verhindern
+- Für rohen HTML-Code verwenden Sie den EscapeProcessor mit der Syntax `{{{ variableName }}}`
diff --git a/src/Framework/View/Processors/docs/README.md b/src/Framework/View/Processors/docs/README.md
new file mode 100644
index 00000000..81501a87
--- /dev/null
+++ b/src/Framework/View/Processors/docs/README.md
@@ -0,0 +1,110 @@
+# DOM-Prozessoren Dokumentation
+
+## Überblick
+
+Die DOM-Prozessoren in `src/Framework/View/Processors` sind modulare Komponenten zur Verarbeitung und Manipulation von HTML-Dokumenten. Sie implementieren das `DomProcessor`-Interface und werden vom Template-System verwendet, um dynamische Inhalte, Layouts und Komponenten in Templates einzufügen.
+
+## Das DomProcessor Interface
+
+```php
+interface DomProcessor
+{
+    public function process(HTMLDocument $dom, RenderContext $context): void;
+}
+```
+
+Jeder Prozessor erhält:
+- Ein `HTMLDocument`-Objekt (PHP 8.4's HTML5 Parser)
+- Einen `RenderContext` mit Daten und Slots
+
+## Verfügbare Prozessoren
+
+| Prozessor | Beschreibung | Dokumentation |
+|-----------|-------------|---------------|
+| PlaceholderReplacer | Ersetzt Platzhalter in Text und Attributen | [Dokumentation](PlaceholderReplacer.md) |
+| IncludeProcessor | Bindet externe HTML-Dateien ein | [Dokumentation](IncludeProcessor.md) |
+| LayoutTagProcessor | Implementiert ein Layout-System | [Dokumentation](LayoutTagProcessor.md) |
+| ComponentProcessor | Ermöglicht wiederverwendbare UI-Komponenten | [Dokumentation](ComponentProcessor.md) |
+| SlotProcessor | Implementiert ein Slot-System für Komponenten | [Dokumentation](SlotProcessor.md) |
+| IfProcessor | Bedingte Darstellung von Elementen | [Dokumentation](IfProcessor.md) |
+| ForProcessor | Iteration über Arrays/Sammlungen | [Dokumentation](ForProcessor.md) |
+| AssetInjector | Fügt JS/CSS-Assets aus dem Vite-Manifest ein | [Dokumentation](AssetInjector.md) |
+| MetaManipulator | Extrahiert Metadaten aus Meta-Tags | [Dokumentation](MetaManipulator.md) |
+| EscapeProcessor | Escaping von Variablen (String-Prozessor) | [Dokumentation](EscapeProcessor.md) |
+| DateFormatProcessor | Formatiert Datums- und Zeitwerte | [Dokumentation](DateFormatProcessor.md) |
+| SwitchCaseProcessor | Ermöglicht switch/case-Logik in Templates | [Dokumentation](SwitchCaseProcessor.md) |
+| CommentStripProcessor | Entfernt HTML-Kommentare | [Dokumentation](CommentStripProcessor.md) |
+| SingleLineHtmlProcessor | Konvertiert mehrzeilige HTML-Elemente in einzeilige | [Dokumentation](SingleLineHtmlProcessor.md) |
+| RemoveEmptyLinesProcessor | Entfernt leere Zeilen aus dem HTML | [Dokumentation](RemoveEmptyLinesProcessor.md) |
+| VoidElementsSelfClosingProcessor | Korrigiert selbstschließende Tags | [Dokumentation](VoidElementsSelfClosingProcessor.md) |
+
+## Anwendungsreihenfolge
+
+Prozessoren werden typischerweise in der folgenden Reihenfolge angewendet:
+
+1. **Strukturprozessoren**
+   - LayoutTagProcessor
+   - IncludeProcessor
+
+2. **Komponentenprozessoren**
+   - ComponentProcessor
+   - SlotProcessor
+
+3. **Logikprozessoren**
+   - IfProcessor
+   - ForProcessor
+   - SwitchCaseProcessor
+
+4. **Inhaltsprozessoren**
+   - PlaceholderReplacer
+   - DateFormatProcessor
+   - MetaManipulator
+
+5. **Asset-Prozessoren**
+   - AssetInjector
+
+6. **Optimierungsprozessoren**
+   - CommentStripProcessor
+   - RemoveEmptyLinesProcessor
+   - SingleLineHtmlProcessor
+   - VoidElementsSelfClosingProcessor
+
+## Anwendungsbeispiel
+
+```php
+// Template-Engine mit Prozessoren konfigurieren
+$templateEngine = new TemplateEngine();
+
+// Strukturprozessoren
+$templateEngine->addProcessor(new LayoutTagProcessor());
+$templateEngine->addProcessor(new IncludeProcessor());
+
+// Komponentenprozessoren
+$templateEngine->addProcessor(new ComponentProcessor());
+$templateEngine->addProcessor(new SlotProcessor());
+
+// Logikprozessoren
+$templateEngine->addProcessor(new IfProcessor());
+$templateEngine->addProcessor(new ForProcessor());
+
+// Inhaltsprozessoren
+$templateEngine->addProcessor(new PlaceholderReplacer());
+$templateEngine->addProcessor(new MetaManipulator());
+
+// Template rendern
+$html = $templateEngine->render('template.html', ['key' => 'value']);
+```
+
+## Eigene Prozessoren erstellen
+
+Um einen eigenen Prozessor zu erstellen, implementieren Sie das `DomProcessor`-Interface:
+
+```php
+class MyCustomProcessor implements DomProcessor
+{
+    public function process(HTMLDocument $dom, RenderContext $context): void
+    {
+        // DOM-Manipulation hier
+    }
+}
+```
diff --git a/src/Framework/View/Processors/docs/RemoveEmptyLinesProcessor.md b/src/Framework/View/Processors/docs/RemoveEmptyLinesProcessor.md
new file mode 100644
index 00000000..cebadefa
--- /dev/null
+++ b/src/Framework/View/Processors/docs/RemoveEmptyLinesProcessor.md
@@ -0,0 +1,65 @@
+# RemoveEmptyLinesProcessor
+
+## Überblick
+
+Der `RemoveEmptyLinesProcessor` entfernt leere Zeilen aus dem HTML-Output, um die Größe zu reduzieren.
+
+## Funktionsweise
+
+- Verarbeitet den HTML-String nach der DOM-Verarbeitung
+- Entfernt Zeilen, die nur Whitespace enthalten
+- Behält die HTML-Struktur bei, reduziert aber die Formatierung
+
+## Vorher / Nachher
+
+**Vorher:**
+```html
+<div>
+
+    <p>Absatz 1</p>
+
+    <p>Absatz 2</p>
+
+</div>
+```
+
+**Nachher:**
+```html
+<div>
+    <p>Absatz 1</p>
+    <p>Absatz 2</p>
+</div>
+```
+
+## Implementierung
+
+Der Prozessor verwendet reguläre Ausdrücke, um leere Zeilen zu finden und zu entfernen. Eine leere Zeile wird definiert als eine Zeile, die nur Whitespace (Leerzeichen, Tabs, etc.) enthält.
+
+## Konfigurationsoptionen
+
+- **preserveSpecialElements**: (Boolean) Bei `true` werden leere Zeilen innerhalb bestimmter Elemente (wie `<pre>` oder `<textarea>`) beibehalten
+
+## Erhaltene Elemente
+
+Bei bestimmten Elementen, in denen Whitespace wichtig ist, kann die Formatierung erhalten bleiben:
+
+- `<pre>` und `<code>` Elemente
+- `<textarea>` Elemente
+
+## Vorteile
+
+- Reduziert die Größe der HTML-Ausgabe
+- Behält die grundlegende Formatierung für bessere Lesbarkeit bei
+- Minimale Auswirkung auf die Darstellung im Browser
+
+## Anwendungsfälle
+
+- Moderate Optimierung für Produktionsumgebungen
+- Reduzierung der Bandbreitennutzung
+- Säuberung von HTML-Ausgabe mit übermäßigen Leerzeilen
+
+## Tipps
+
+- Verwenden Sie diesen Prozessor vor dem `SingleLineHtmlProcessor` für eine stufenweise Komprimierung
+- Für maximale Komprimierung kombinieren Sie ihn mit `CommentStripProcessor` und `SingleLineHtmlProcessor`
+- Dieser Prozessor bietet einen guten Kompromiss zwischen Komprimierung und Lesbarkeit
diff --git a/src/Framework/View/Processors/docs/SingleLineHtmlProcessor.md b/src/Framework/View/Processors/docs/SingleLineHtmlProcessor.md
new file mode 100644
index 00000000..f1814166
--- /dev/null
+++ b/src/Framework/View/Processors/docs/SingleLineHtmlProcessor.md
@@ -0,0 +1,63 @@
+# SingleLineHtmlProcessor
+
+## Überblick
+
+Der `SingleLineHtmlProcessor` konvertiert mehrzeilige HTML-Elemente in einzeilige, um die Größe der Ausgabe zu reduzieren.
+
+## Funktionsweise
+
+- Verarbeitet den HTML-String nach der DOM-Verarbeitung
+- Entfernt Zeilenumbrüche und überschüssige Leerzeichen
+- Behält die HTML-Struktur bei, reduziert aber die Formatierung
+
+## Vorher / Nachher
+
+**Vorher:**
+```html
+<div>
+    <p>
+        Dies ist ein Absatz mit
+        mehreren Zeilen
+    </p>
+</div>
+```
+
+**Nachher:**
+```html
+<div><p>Dies ist ein Absatz mit mehreren Zeilen</p></div>
+```
+
+## Implementierung
+
+Der Prozessor verwendet reguläre Ausdrücke oder DOM-Traversierung, um mehrzeilige Elemente zu identifizieren und zu komprimieren. Zeilenumbrüche innerhalb von Tags werden entfernt, während Textinhalt beibehalten wird.
+
+## Konfigurationsoptionen
+
+- **preserveTextLineBreaks**: (Boolean) Bei `true` werden Zeilenumbrüche in Textknoten als Leerzeichen beibehalten
+- **preservePreTags**: (Boolean) Bei `true` wird der Inhalt von `<pre>` Tags nicht verändert
+
+## Erhaltene Elemente
+
+Bei bestimmten Elementen, in denen Whitespace wichtig ist, kann die Formatierung erhalten bleiben:
+
+- `<pre>` und `<code>` Elemente
+- `<textarea>` Elemente
+- Elemente mit `white-space: pre` im Stil
+
+## Vorteile
+
+- Reduziert die Größe der HTML-Ausgabe
+- Verbessert die Ladezeit
+- Minimale Auswirkung auf die Darstellung im Browser
+
+## Anwendungsfälle
+
+- Optimierung für Produktionsumgebungen
+- Reduzierung der Bandbreitennutzung
+- Vorbereitung für weitere Komprimierung (z.B. Gzip)
+
+## Tipps
+
+- Verwenden Sie diesen Prozessor als einen der letzten Schritte in der Verarbeitungskette
+- Kombinieren Sie ihn mit `CommentStripProcessor` und `RemoveEmptyLinesProcessor` für maximale Komprimierung
+- Beachten Sie, dass die Lesbarkeit des HTML-Codes für Entwickler reduziert wird
diff --git a/src/Framework/View/Processors/docs/SlotProcessor.md b/src/Framework/View/Processors/docs/SlotProcessor.md
new file mode 100644
index 00000000..ca669adc
--- /dev/null
+++ b/src/Framework/View/Processors/docs/SlotProcessor.md
@@ -0,0 +1,58 @@
+# SlotProcessor
+
+## Überblick
+
+Der `SlotProcessor` implementiert ein Slot-System für Komponenten, das die flexible Platzierung von Inhalten innerhalb von Komponenten ermöglicht.
+
+## Funktionsweise
+
+- Findet `<slot>`-Tags im DOM
+- Ersetzt diese durch den im RenderContext definierten Slot-Inhalt
+- Falls kein Inhalt definiert ist, wird der Default-Inhalt des Slots verwendet
+
+## Syntax
+
+```html
+<slot name="slotName">Default-Inhalt</slot>
+```
+
+## Beispiel
+
+**Komponentendefinition:**
+```html
+<div class="card">
+    <div class="card-header">
+        <slot name="header">Standard-Header</slot>
+    </div>
+    <div class="card-body">
+        <slot>Standard-Inhalt</slot>
+    </div>
+</div>
+```
+
+**Verwendung:**
+```html
+<component name="card">
+    <div slot="header">Mein benutzerdefinierter Header</div>
+    <p>Mein Inhalt für den Default-Slot</p>
+</component>
+```
+
+## Implementierung
+
+Der Prozessor sucht nach `<slot>`-Tags mit einem `name`-Attribut und ersetzt sie durch den entsprechenden Inhalt aus dem `slots`-Array des RenderContext. Wenn kein passender Slot-Inhalt gefunden wird, wird der innere Inhalt des `<slot>`-Tags als Fallback verwendet.
+
+## Benannte vs. Default-Slots
+
+- **Benannte Slots**: Haben ein `name`-Attribut und werden durch Inhalte mit passendem `slot`-Attribut ersetzt
+- **Default-Slot**: Hat kein `name`-Attribut und wird durch den Hauptinhalt der Komponente ersetzt
+
+## Integration mit ComponentProcessor
+
+Der SlotProcessor wird normalerweise nach dem ComponentProcessor ausgeführt, um die Slots innerhalb der gerenderten Komponenten zu verarbeiten. Die Komponenten-Templates definieren die Slots, während der Aufruf der Komponente die Inhalte für diese Slots bereitstellt.
+
+## Vorteile
+
+- Ermöglicht flexible, anpassbare Komponenten
+- Unterstützt komplexe UI-Strukturen mit variabler Inhaltsplatzierung
+- Ähnlich dem Slot-Konzept in Web Components und modernen Frontend-Frameworks
diff --git a/src/Framework/View/Processors/docs/SwitchCaseProcessor.md b/src/Framework/View/Processors/docs/SwitchCaseProcessor.md
new file mode 100644
index 00000000..e558b0a4
--- /dev/null
+++ b/src/Framework/View/Processors/docs/SwitchCaseProcessor.md
@@ -0,0 +1,63 @@
+# SwitchCaseProcessor
+
+## Überblick
+
+Der `SwitchCaseProcessor` ermöglicht switch/case-Logik in Templates, ähnlich wie in Programmiersprachen.
+
+## Funktionsweise
+
+- Findet `<switch>`-Tags mit einem `value`-Attribut
+- Vergleicht den Wert mit den `value`-Attributen der enthaltenen `<case>`-Tags
+- Zeigt nur den Inhalt des ersten passenden `<case>`-Tags an
+- Falls kein Fall passt, wird der Inhalt des `<default>`-Tags angezeigt (wenn vorhanden)
+
+## Syntax
+
+```html
+<switch value="expression">
+    <case value="value1">Inhalt für value1</case>
+    <case value="value2">Inhalt für value2</case>
+    <default>Fallback-Inhalt</default>
+</switch>
+```
+
+## Beispiel
+
+```html
+<switch value="{{ status }}">
+    <case value="active">Aktiv</case>
+    <case value="pending">Ausstehend</case>
+    <case value="suspended">Gesperrt</case>
+    <default>Unbekannter Status</default>
+</switch>
+```
+
+## Implementierung
+
+Der Prozessor findet alle `<switch>`-Tags und deren `<case>`- und `<default>`-Kinder. Er vergleicht den im `value`-Attribut des `<switch>`-Tags angegebenen Wert mit den Werten der `<case>`-Tags und behält nur den passenden Fall bei. Alle nicht passenden Fälle werden aus dem DOM entfernt.
+
+## Mehrere passende Fälle
+
+Wenn mehrere `<case>`-Tags dem Wert entsprechen, wird nur der erste passende Fall berücksichtigt. Die anderen werden entfernt, ähnlich wie bei einem `break` in einer Programmiersprache.
+
+## Default-Fall
+
+Der `<default>`-Tag wird nur angezeigt, wenn kein `<case>`-Tag passt. Er benötigt kein `value`-Attribut.
+
+## Dynamische Werte
+
+Das `value`-Attribut des `<switch>`-Tags kann mit Platzhaltern verwendet werden:
+
+```html
+<switch value="{{ userRole }}">
+    <case value="admin">Administratorbereich</case>
+    <case value="moderator">Moderatorbereich</case>
+    <default>Benutzerbereich</default>
+</switch>
+```
+
+## Vorteile
+
+- Elegantere Alternative zu verschachtelten `if`-Bedingungen
+- Verbessert die Lesbarkeit bei mehreren Bedingungen
+- Ideal für Status-basierte Anzeigen, Benutzerberechtigungen, etc.
diff --git a/src/Framework/View/Processors/docs/VoidElementsSelfClosingProcessor.md b/src/Framework/View/Processors/docs/VoidElementsSelfClosingProcessor.md
new file mode 100644
index 00000000..90efa6e4
--- /dev/null
+++ b/src/Framework/View/Processors/docs/VoidElementsSelfClosingProcessor.md
@@ -0,0 +1,80 @@
+# VoidElementsSelfClosingProcessor
+
+## Überblick
+
+Der `VoidElementsSelfClosingProcessor` stellt sicher, dass leere Elemente (Void Elements) korrekt als selbstschließende Tags formatiert sind.
+
+## Funktionsweise
+
+- Identifiziert HTML-Void-Elemente (Elemente ohne Endtag)
+- Korrigiert ihre Formatierung gemäß HTML5-Standard
+- Stellt sicher, dass selbstschließende Tags korrekt dargestellt werden
+
+## Betroffe Elemente
+
+Die folgenden Elemente sind HTML5-Void-Elemente und werden vom Prozessor behandelt:
+
+- `area`
+- `base`
+- `br`
+- `col`
+- `embed`
+- `hr`
+- `img`
+- `input`
+- `link`
+- `meta`
+- `param`
+- `source`
+- `track`
+- `wbr`
+
+## Vorher / Nachher
+
+**Korrektur für HTML5:**
+
+```html
+<!-- Falsch (XML-Stil) -->
+<img src="bild.jpg" alt="Bild" />
+
+<!-- Korrekt (HTML5) -->
+<img src="bild.jpg" alt="Bild">
+```
+
+**Oder:**
+
+```html
+<!-- Falsch (fehlendes Attribut) -->
+<input>
+
+<!-- Korrekt (mit Attribut) -->
+<input type="text">
+```
+
+## Implementierung
+
+Der Prozessor durchsucht das DOM nach Void-Elementen und stellt sicher, dass sie gemäß HTML5-Standard formatiert sind. Er kann auch prüfen, ob erforderliche Attribute vorhanden sind.
+
+## HTML5 vs. XML/XHTML
+
+- In HTML5 haben Void-Elemente kein schließendes Tag und keinen abschließenden Schrägstrich
+- In XML/XHTML müssen Void-Elemente selbstschließend sein (`<tag />`) 
+
+Dieser Prozessor standardisiert auf HTML5-Format, es sei denn, er wird anders konfiguriert.
+
+## Konfigurationsoptionen
+
+- **outputMode**: Kann auf "html5" oder "xhtml" gesetzt werden, um das Ausgabeformat zu bestimmen
+- **enforceRequiredAttributes**: Wenn aktiviert, werden Warnungen für fehlende erforderliche Attribute generiert
+
+## Vorteile
+
+- Konsistente HTML-Ausgabe
+- Vermeidet potenzielle Rendering-Probleme in verschiedenen Browsern
+- Verbessert die Gültigkeit des HTML-Codes
+
+## Tipps
+
+- Dieser Prozessor sollte vor Optimierungsprozessoren wie dem CommentStripProcessor ausgeführt werden
+- In HTML5-Projekten sollten Void-Elemente ohne schließenden Schrägstrich verwendet werden
+- In XML/XHTML-Projekten sollten Void-Elemente immer selbstschließend sein
diff --git a/src/Framework/View/RenderContext.php b/src/Framework/View/RenderContext.php
index 1cf7f7aa..e4339838 100644
--- a/src/Framework/View/RenderContext.php
+++ b/src/Framework/View/RenderContext.php
@@ -2,13 +2,16 @@
 
 namespace App\Framework\View;
 
+use App\Framework\Meta\MetaData;
+
 final readonly class RenderContext
 {
     public function __construct(
         public string $template,       // Dateiname oder Template-Key
+        public MetaData $metaData,
         public array $data = [],       // Variablen wie ['title' => '...']
         public ?string $layout = null, // Optionales Layout
         public array $slots = [],       // Benannte Slots wie ['main' => '<p>...</p>']
-        public ?string $controllerClass = null
+        public ?string $controllerClass = null,
     ) {}
 }
diff --git a/src/Framework/View/Renderer.php b/src/Framework/View/Renderer.php
deleted file mode 100644
index 18e773cf..00000000
--- a/src/Framework/View/Renderer.php
+++ /dev/null
@@ -1,145 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace App\Framework\View;
-
-use App\Framework\View\Processors\CommentStripProcessor;
-use App\Framework\View\Processors\ComponentProcessor;
-use App\Framework\View\Processors\LayoutTagProcessor;
-use App\Framework\View\Processors\MetaManipulator;
-use App\Framework\View\Processors\PlaceholderReplacer;
-
-final readonly class Renderer
-{
-    public function __construct(
-        private TemplateManipulator $manipulator = new TemplateManipulator(
-            new LayoutTagProcessor(),
-            #new PlaceholderReplacer(),
-            new MetaManipulator(),
-            new ComponentProcessor(),
-            new CommentStripProcessor()
-        )
-    ){}
-    public function render(\DOMDocument $dom, array $data, Engine $engine): string
-    {
-        $componentRenderer = function (string $name, array $attributes, array $data) use ($engine) {
-            $filename = __DIR__ . "/templates/components/$name.html";
-            if (!file_exists($filename)) {
-                return "<!-- Komponente '$name' nicht gefunden -->";
-            }
-            $content = file_get_contents($filename);
-            // Optional: Rekursive/statische Komponentenverarbeitung
-            return $this->renderComponentPartial($content, array_merge($data, $attributes), $engine);
-        };
-
-        $this->manipulator->manipulate($dom, $data, $componentRenderer);
-
-
-        $xpath = new \DOMXPath($dom);
-
-
-        // 2. Schleifen <for var="item" in="items"></for>
-        foreach ($xpath->query('//*[local-name() = "for"]') as $forNode) {
-            $var = $forNode->getAttribute('var');
-            $in = $forNode->getAttribute('in');
-            $html = '';
-            if (isset($data[$in]) && is_iterable($data[$in])) {
-                foreach ($data[$in] as $item) {
-                    $clone = $forNode->cloneNode(true);
-                    foreach ($clone->childNodes as $node) {
-                        $this->renderNode($node, [$var => $item] + $data);
-                    }
-                    $frag = $dom->createDocumentFragment();
-                    foreach ($clone->childNodes as $child) {
-                        $frag->appendChild($child->cloneNode(true));
-                    }
-                    $html .= $dom->saveHTML($frag);
-                }
-            }
-            // Ersetze das <for>-Element
-            $fragment = $dom->createDocumentFragment();
-            $fragment->appendXML($html);
-            $forNode->parentNode->replaceChild($fragment, $forNode);
-        }
-
-        // Analog: <if>- und <include>-Elemente einbauen (optional, auf Anfrage)
-
-        return $dom->saveHTML();
-    }
-
-    private function renderNode(\DOMNode $node, array $data): void
-    {
-        // Rekursiv auf allen Kindknoten Platzhalter ersetzen (wie oben)
-        if ($node->nodeType === XML_TEXT_NODE) {
-            $original = $node->nodeValue;
-            $replaced = preg_replace_callback('/{{\s*(\w+(?:\.\w+)*)\s*}}/', function ($matches) use ($data) {
-                $keys = explode('.', $matches[1]);
-                $value = $data;
-                foreach ($keys as $key) {
-                    $value = is_array($value) && array_key_exists($key, $value) ? $value[$key] : $matches[0];
-                }
-
-                return is_scalar($value)
-                    ? htmlspecialchars((string)$value, ENT_QUOTES | ENT_HTML5)
-                    : $matches[0];
-            }, $original);
-            if ($original !== $replaced) {
-                $node->nodeValue = $replaced;
-            }
-        }
-        if ($node->hasChildNodes()) {
-            foreach ($node->childNodes as $child) {
-                $this->renderNode($child, $data);
-            }
-        }
-    }
-
-    /**
-     * Rendert ein Komponententemplate inklusive rekursivem Komponenten-Parsing.
-     */
-    private function renderComponentPartial(string $content, array $data, Engine $engine): string
-    {
-        $cacheDir = __DIR__ . "/cache/components";
-        if (!is_dir($cacheDir)) {
-            mkdir($cacheDir, 0777, true);
-        }
-
-        $hash = md5($content . serialize($data));
-        $cacheFile = $cacheDir . "/component_$hash.html";
-
-        if (file_exists($cacheFile)) {
-            return file_get_contents($cacheFile);
-        }
-
-
-        $dom = new \DOMDocument();
-        @$dom->loadHTML('<!DOCTYPE html><html lang="de"><body>'.$content.'</body></html>');
-
-        // Komponenten innerhalb des Partials auflösen (rekursiv!)
-        $this->manipulator->processComponents(
-            $dom,
-            $data,
-            function ($name, $attributes, $data) use ($engine) {
-                $filename = __DIR__ . "/templates/components/$name.html";
-                if (!file_exists($filename)) {
-                    return "<!-- Komponente '$name' nicht gefunden -->";
-                }
-                $subContent = file_get_contents($filename);
-                return $this->renderComponentPartial($subContent, array_merge($data, $attributes), $engine);
-            }
-        );
-        // Platzhalter in diesem Partial ersetzen
-        $this->manipulator->replacePlaceholders($dom, $data);
-
-        // Nur den Inhalt von <body> extrahieren
-        $body = $dom->getElementsByTagName('body')->item(0);
-        $innerHTML = '';
-        foreach ($body->childNodes as $child) {
-            $innerHTML .= $dom->saveHTML($child);
-        }
-        file_put_contents($cacheFile, $innerHTML);
-        return $innerHTML;
-    }
-
-}
diff --git a/src/Framework/View/Template.php b/src/Framework/View/Template.php
new file mode 100644
index 00000000..2e18fd76
--- /dev/null
+++ b/src/Framework/View/Template.php
@@ -0,0 +1,14 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\View;
+
+use Attribute;
+
+#[Attribute(Attribute::TARGET_CLASS)]
+final class Template
+{
+    public function __construct(public string $path) {
+
+    }
+}
diff --git a/src/Framework/View/TemplateDiscoveryVisitor.php b/src/Framework/View/TemplateDiscoveryVisitor.php
new file mode 100644
index 00000000..ad46afa3
--- /dev/null
+++ b/src/Framework/View/TemplateDiscoveryVisitor.php
@@ -0,0 +1,189 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\View;
+
+use App\Framework\Cache\Cache;
+use App\Framework\Discovery\FileVisitor;
+
+/**
+ * Visitor zum Auffinden von Templates
+ */
+final class TemplateDiscoveryVisitor implements FileVisitor
+{
+    private array $templates = [];
+    private array $scannedDirectories = [];
+    private string $templateExtension;
+    private ?array $templateLookupIndex = null;
+
+    public function __construct(string $templateExtension = '.view.php')
+    {
+        $this->templateExtension = $templateExtension;
+    }
+
+    public function onScanStart(): void
+    {
+        $this->templates = [];
+        $this->scannedDirectories = [];
+        $this->templateLookupIndex = null;
+    }
+
+    public function visitClass(string $className, string $filePath): void
+    {
+        // Hier prüfen wir nicht auf Klassen, sondern auf Template-Dateien
+        $directory = dirname($filePath);
+
+        // Vermeide mehrfaches Scannen desselben Verzeichnisses
+        if (isset($this->scannedDirectories[$directory])) {
+            return;
+        }
+
+        $this->scannedDirectories[$directory] = true;
+
+        // Suche Templates im selben Verzeichnis wie die Klasse
+        $templateFiles = glob($directory . '/*' . $this->templateExtension);
+
+        foreach ($templateFiles as $templateFile) {
+            $filename = basename($templateFile);
+            $templateName = substr($filename, 0, -strlen($this->templateExtension));
+
+            if (!isset($this->templates[$templateName])) {
+                $this->templates[$templateName] = [];
+            }
+
+            // Ordne das Template der Klasse zu, wenn sie im selben Verzeichnis ist
+            $this->templates[$templateName][$className] = $templateFile;
+
+            // Füge auch einen Standard-Eintrag ohne Klasse hinzu
+            $this->templates[$templateName][''] = $templateFile;
+        }
+    }
+
+    public function onScanComplete(): void
+    {
+        // Erstelle einen Index für schnelleren Zugriff
+        $this->createTemplateLookupIndex();
+    }
+
+    /**
+     * Wird aufgerufen, wenn ein inkrementeller Scan beginnt
+     */
+    public function onIncrementalScanStart(): void
+    {
+        // Behalte vorhandene Templates bei, setze nur scannedDirectories zurück
+        $this->scannedDirectories = [];
+        $this->templateLookupIndex = null;
+    }
+
+    /**
+     * Wird aufgerufen, wenn ein inkrementeller Scan abgeschlossen ist
+     */
+    public function onIncrementalScanComplete(): void
+    {
+        // Aktualisiere den Index nach inkrementellem Scan
+        $this->createTemplateLookupIndex();
+    }
+
+    /**
+     * Erstellt einen Index für schnelleren Template-Zugriff
+     */
+    private function createTemplateLookupIndex(): void
+    {
+        $this->templateLookupIndex = [];
+
+        foreach ($this->templates as $templateName => $variants) {
+            foreach ($variants as $className => $path) {
+                $key = $this->buildLookupKey($templateName, $className);
+                $this->templateLookupIndex[$key] = $path;
+            }
+        }
+    }
+
+    /**
+     * Erstellt einen eindeutigen Lookup-Schlüssel für ein Template
+     */
+    private function buildLookupKey(string $templateName, string $className = ''): string
+    {
+        return $templateName . '|' . $className;
+    }
+
+    /**
+     * Lädt Daten aus dem Cache
+     */
+    public function loadFromCache(Cache $cache): void
+    {
+        $cacheItem = $cache->get($this->getCacheKey());
+        if ($cacheItem->isHit) {
+            $this->templates = $cacheItem->value;
+            $this->createTemplateLookupIndex();
+        }
+    }
+
+    public function getCacheKey(): string
+    {
+        return 'templates';
+    }
+
+    /**
+     * Liefert die zu cachenden Daten des Visitors
+     */
+    public function getCacheableData(): array
+    {
+        return $this->templates;
+    }
+
+    /**
+     * Gibt den Pfad eines Templates zurück
+     */
+    public function getTemplatePath(string $templateName, ?string $className = null): ?string
+    {
+        // Verwende den Index für schnelleren Zugriff, wenn verfügbar
+        if ($this->templateLookupIndex !== null) {
+            $key = $this->buildLookupKey($templateName, $className ?? '');
+            if (isset($this->templateLookupIndex[$key])) {
+                return $this->templateLookupIndex[$key];
+            }
+
+            // Fallback auf Standard-Template
+            $fallbackKey = $this->buildLookupKey($templateName, '');
+            return $this->templateLookupIndex[$fallbackKey] ?? null;
+        }
+
+        // Klassische Suche als Fallback
+        if (isset($this->templates[$templateName][$className ?? ''])) {
+            return $this->templates[$templateName][$className ?? ''];
+        }
+
+        return $this->templates[$templateName][''] ?? null;
+    }
+
+    /**
+     * Gibt alle gefundenen Templates zurück
+     */
+    public function getAllTemplates(): array
+    {
+        return $this->templates;
+    }
+
+    /**
+     * Gibt alle Templates in einem bestimmten Verzeichnis zurück
+     */
+    public function getTemplatesInDirectory(string $directory): array
+    {
+        $result = [];
+        $normalizedDirectory = rtrim($directory, '/');
+
+        foreach ($this->templates as $templateName => $variants) {
+            foreach ($variants as $className => $path) {
+                if (dirname($path) === $normalizedDirectory) {
+                    if (!isset($result[$templateName])) {
+                        $result[$templateName] = [];
+                    }
+                    $result[$templateName][$className] = $path;
+                }
+            }
+        }
+
+        return $result;
+    }
+}
diff --git a/src/Framework/View/TemplateFunctions.php b/src/Framework/View/TemplateFunctions.php
new file mode 100644
index 00000000..d068e734
--- /dev/null
+++ b/src/Framework/View/TemplateFunctions.php
@@ -0,0 +1,31 @@
+<?php
+
+namespace App\Framework\View;
+
+use App\Framework\DI\Container;
+use App\Framework\View\Functions\TemplateFunction;
+
+final readonly class TemplateFunctions
+{
+    private array $functions;
+    public function __construct(
+        private Container $container, string ...$templateFunctions)
+    {
+        $functions = [];
+        foreach ($templateFunctions as $function) {
+            $functionInstance = $this->container->get($function);
+            $functions[$functionInstance->functionName] = $functionInstance;
+        }
+        $this->functions = $functions;
+    }
+
+    public function has(string $functionName): bool
+    {
+        return isset($this->functions[$functionName]);
+    }
+
+    public function get(string $functionName): ?TemplateFunction
+    {
+        return $this->functions[$functionName] ?? null;
+    }
+}
diff --git a/src/Framework/View/TemplateLoader.php b/src/Framework/View/TemplateLoader.php
deleted file mode 100644
index 1e4b2213..00000000
--- a/src/Framework/View/TemplateLoader.php
+++ /dev/null
@@ -1,38 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace App\Framework\View;
-
-final readonly class TemplateLoader
-{
-    public function __construct(
-        private string $templatePath = __DIR__ . '/templates'
-    ) {
-    }
-
-    public function load(string $template, ?string $controllerClass = null): string
-    {
-        $file = $this->getTemplatePath($template, $controllerClass);
-        if (! file_exists($file)) {
-            throw new \RuntimeException("Template \"$template\" nicht gefunden ($file).");
-        }
-
-        return file_get_contents($file);
-    }
-
-    public function getTemplatePath(string $template, ?string $controllerClass = null): string
-    {
-        if($controllerClass) {
-            $rc = new \ReflectionClass($controllerClass);
-            $dir = dirname($rc->getFileName());
-            return $dir . DIRECTORY_SEPARATOR . $template . '.html';
-        }
-        return $this->templatePath . '/' . $template . '.html';
-    }
-
-    public function getComponentPath(string $name): string
-    {
-        return __DIR__ . "/templates/components/{$name}.html";
-    }
-}
diff --git a/src/Framework/View/TemplateManipulator.php b/src/Framework/View/TemplateManipulator.php
deleted file mode 100644
index 3663d375..00000000
--- a/src/Framework/View/TemplateManipulator.php
+++ /dev/null
@@ -1,73 +0,0 @@
-<?php
-
-namespace App\Framework\View;
-
-final readonly class TemplateManipulator
-{
-    private array $processors;
-    public function __construct(
-        DomProcessor ...$processor
-    ){
-        $this->processors = $processor;
-    }
-
-    public function manipulate(\DOMDocument $dom, array $data, callable $componentRenderer):void
-    {
-        $xpath = new \DOMXPath($dom);
-        foreach ($xpath->query('//*') as $element) {
-            if (!$element instanceof \DOMElement) continue;
-            foreach ($this->processors as $processor) {
-                if ($processor->supports($element)) {
-                    $processor->process($dom, $data, $componentRenderer);
-                }
-            }
-        }
-
-    }
-
-    // Du könntest hier noch Platzhalter, Komponenten etc. ergänzen
-    public function replacePlaceholders(\DOMDocument $dom, array $data): void
-    {
-        // Einfaches Beispiel für {{ variable }}-Platzhalter in Textknoten
-        $xpath = new \DOMXPath($dom);
-        foreach ($xpath->query('//text()') as $textNode) {
-            foreach ($data as $key => $value) {
-                $placeholder = '{{ ' . $key . ' }}';
-                if (str_contains($textNode->nodeValue, $placeholder)) {
-                    $textNode->nodeValue = str_replace($placeholder, $value, $textNode->nodeValue);
-                }
-            }
-        }
-    }
-
-    /**
-     * Parst und ersetzt <component>-Elemente im DOM.
-     * @param \DOMDocument $dom
-     * @param array $data
-     * @param callable $componentRenderer Funktion: (Name, Attribute, Daten) => HTML
-     */
-    public function processComponents(\DOMDocument $dom, array $data, callable $componentRenderer): void
-    {
-        $xpath = new \DOMXPath($dom);
-
-        // Alle <component>-Elemente durchgehen (XPath ist hier namespace-unabhängig)
-        foreach ($xpath->query('//component') as $componentNode) {
-            /** @var \DOMElement $componentNode */
-            $name = $componentNode->getAttribute('name');
-            // Alle Attribute als Array sammeln
-            $attributes = [];
-            foreach ($componentNode->attributes as $attr) {
-                $attributes[$attr->nodeName] = $attr->nodeValue;
-            }
-
-            // Hole das gerenderte HTML für diese Komponente
-            $componentHtml = $componentRenderer($name, $attributes, $data);
-
-            // Ersetze das Node durch neues HTML-Fragment
-            $fragment = $dom->createDocumentFragment();
-            $fragment->appendXML($componentHtml);
-            $componentNode->parentNode->replaceChild($fragment, $componentNode);
-        }
-    }
-
-}
diff --git a/src/Framework/View/TemplateMapper.php b/src/Framework/View/TemplateMapper.php
new file mode 100644
index 00000000..cadd1368
--- /dev/null
+++ b/src/Framework/View/TemplateMapper.php
@@ -0,0 +1,28 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\View;
+
+use App\Framework\Core\AttributeMapper;
+use ReflectionMethod;
+
+final class TemplateMapper implements AttributeMapper
+{
+    public function getAttributeClass(): string
+    {
+        return Template::class;
+    }
+
+    public function map(object $reflectionTarget, object $attributeInstance): ?array
+    {
+        if (!$attributeInstance instanceof Template) {
+            return null;
+        }
+
+        return [
+            'class' => $reflectionTarget->getName(),
+            #'method' => $reflectionTarget->getName(),
+            'path' => $attributeInstance->path,
+        ];
+    }
+}
diff --git a/src/Framework/View/TemplateProcessor.php b/src/Framework/View/TemplateProcessor.php
index 84bdd89e..0c906659 100644
--- a/src/Framework/View/TemplateProcessor.php
+++ b/src/Framework/View/TemplateProcessor.php
@@ -2,39 +2,82 @@
 
 namespace App\Framework\View;
 
-class TemplateProcessor
+use App\Framework\DI\Container;
+use App\Framework\View\Processing\DomProcessingPipeline;
+use Dom\HTMLDocument;
+
+final class TemplateProcessor
 {
-    /** @var DomProcessor[] */
-    private array $domProcessors = [];
+    private array $resolvedProcessors = [];
+    public function __construct(
+        private readonly array $domProcessors,
+        private readonly array $stringProcessors,
+        private readonly Container $container
+    ) {}
 
-    /** @var StringProcessor[] */
-    private array $stringProcessors = [];
-
-    public function registerDom(DomProcessor $processor): void
+    public function render(RenderContext $context, string $html, bool $component = false): string
     {
-        $this->domProcessors[] = $processor;
+        #$dom = $this->processDom($html, $context);
+
+        $domPipeline = new DomProcessingPipeline($this->domProcessors, $this->container->get(ProcessorResolver::class));
+
+        $dom = $domPipeline->process($context, $html);
+
+        $html = $component ? $this->extractBodyContent($dom->document) : $dom->document->saveHTML();
+        #$html = $dom->body->innerHTML;
+
+        return $this->processString($html, $context);
     }
 
-    public function registerString(StringProcessor $processor): void
+    public function __debugInfo(): ?array
     {
-        $this->stringProcessors[] = $processor;
+        return [
+            $this->domProcessors,
+            $this->stringProcessors,
+        ];
     }
 
-    public function render(RenderContext $context, string $html): string
+    private function processDom(string $html, RenderContext $context): HTMLDocument
     {
         $parser = new DomTemplateParser();
         $dom = $parser->parse($html);
 
-        foreach ($this->domProcessors as $processor) {
-            $processor->process($dom, $context);
+        // Verkettete Verarbeitung der DOM-Prozessoren
+        foreach ($this->domProcessors as $processorClass) {
+
+            $processor = $this->resolveProcessor($processorClass);
+
+            if($processor instanceof EnhancedDomProcessor) {
+                $dom = $processor->process(DomWrapper::fromString($dom->saveHtml()), $context)->document;
+                #$dom = $dom->document;
+            } else {
+                $dom = $processor->process($dom, $context);
+            }
         }
+        return $dom;
+    }
 
-        $html = $parser->toHtml($dom);
-
-        foreach ($this->stringProcessors as $processor) {
+    private function processString(string $html, RenderContext $context): string
+    {
+        // Verarbeitung durch String-Prozessoren
+        foreach ($this->stringProcessors as $processorClass) {
+            $processor = $this->resolveProcessor($processorClass);
             $html = $processor->process($html, $context);
         }
 
         return $html;
     }
+
+    public function resolveProcessor(string $processorClass): object
+    {
+        if (!isset($this->resolvedProcessors[$processorClass])) {
+            $this->resolvedProcessors[$processorClass] = $this->container->get($processorClass);;
+        }
+        return $this->resolvedProcessors[$processorClass];
+    }
+
+    private function extractBodyContent(HTMLDocument $dom): string
+    {
+        return $dom->body?->innerHTML ?? '';
+    }
 }
diff --git a/src/Framework/View/TemplateRendererInitializer.php b/src/Framework/View/TemplateRendererInitializer.php
new file mode 100644
index 00000000..14f48c9f
--- /dev/null
+++ b/src/Framework/View/TemplateRendererInitializer.php
@@ -0,0 +1,96 @@
+<?php
+
+namespace App\Framework\View;
+
+use App\Framework\Cache\Cache;
+use App\Framework\Core\PathProvider;
+use App\Framework\DI\DefaultContainer;
+use App\Framework\DI\Initializer;
+use App\Framework\Discovery\FileScanner;
+use App\Framework\Discovery\Results\DiscoveryResults;
+use App\Framework\View\Loading\Resolvers\ControllerResolver;
+use App\Framework\View\Loading\Resolvers\DefaultPathResolver;
+use App\Framework\View\Loading\Resolvers\DiscoveryResolver;
+use App\Framework\View\Loading\Resolvers\TemplateMapResolver;
+use App\Framework\View\Loading\TemplateLoader;
+use App\Framework\View\Loading\TemplatePathResolver;
+use App\Framework\View\Processors\AssetInjector;
+use App\Framework\View\Processors\CommentStripProcessor;
+use App\Framework\View\Processors\ComponentProcessor;
+use App\Framework\View\Processors\CsrfReplaceProcessor;
+use App\Framework\View\Processors\FormProcessor;
+use App\Framework\View\Processors\ForProcessor;
+use App\Framework\View\Processors\HoneypotProcessor;
+use App\Framework\View\Processors\LayoutTagProcessor;
+use App\Framework\View\Processors\MetaManipulator;
+use App\Framework\View\Processors\PlaceholderReplacer;
+use App\Framework\View\Processors\RemoveEmptyLinesProcessor;
+use App\Framework\View\Processors\SingleLineHtmlProcessor;
+use App\Framework\View\Processors\VoidElementsSelfClosingProcessor;
+
+final readonly class TemplateRendererInitializer
+{
+    public function __construct(
+        private DefaultContainer $container,
+        private FileScanner      $scanner,
+        private PathProvider     $pathProvider,
+        private DiscoveryResults $results,
+    ) {}
+
+    #[Initializer]
+    public function __invoke(): TemplateRenderer
+    {
+        $doms = [
+            ComponentProcessor::class,
+            LayoutTagProcessor::class,
+            MetaManipulator::class,
+            ForProcessor::class,
+            AssetInjector::class,
+            CommentStripProcessor::class,
+            RemoveEmptyLinesProcessor::class,
+            FormProcessor::class,
+            HoneypotProcessor::class,
+        ];
+
+        $strings = [
+            PlaceholderReplacer::class,
+            SingleLineHtmlProcessor::class,
+            VoidElementsSelfClosingProcessor::class,
+            CsrfReplaceProcessor::class,
+        ];
+
+        $templateProcessor = new TemplateProcessor(
+            [ComponentProcessor::class, ...$this->results->getInterfaceImplementations(DomProcessor::class)],
+            $this->results->getInterfaceImplementations(StringProcessor::class),
+            $this->container,
+        );
+
+        $templateProcessor = new TemplateProcessor($doms, $strings, $this->container);
+
+        $this->container->singleton(TemplateProcessor::class, $templateProcessor);
+
+        #ViewCacheBootstrap::quickEnable($this->container);
+
+        /*$files = $this->scanner->findFiles($this->pathProvider->getSourcePath(), '*.view.php');
+
+        $templates = [];
+        foreach ($files as $file) {
+            $templates[$file->getFilename()] = $file->getPathname();
+        }*/
+
+        $pathProvider = $this->container->get(PathProvider::class);
+        $cache = $this->container->get(Cache::class);
+
+        $loader = new TemplateLoader(pathProvider: $pathProvider, cache: $cache, discoveryResults: $this->results/*, templates: $templates*/);
+
+        $this->container->singleton(TemplateLoader::class, $loader);
+
+        return new Engine(
+            $loader,
+            $pathProvider,
+            processor: $templateProcessor,
+            container: $this->container,
+            cache: $cache,
+        );
+    }
+}
diff --git a/src/Framework/View/cache/epk.cache.html b/src/Framework/View/cache/epk.cache.html
deleted file mode 100644
index 5a30639f..00000000
--- a/src/Framework/View/cache/epk.cache.html
+++ /dev/null
@@ -1,5 +0,0 @@
-<test><layout src="main"></layout>
-
-<h1>EPK</h1>
-<p>Das ist mein EPK</p>
-</test>
diff --git a/src/Framework/View/cache/impressum.cache.html b/src/Framework/View/cache/impressum.cache.html
deleted file mode 100644
index d0dd2c82..00000000
--- a/src/Framework/View/cache/impressum.cache.html
+++ /dev/null
@@ -1,4 +0,0 @@
-<test><layout src="main"></layout>
-<h1>Impressum!</h1>
-<p>Das ist deine Seite</p>
-</test>
diff --git a/src/Framework/View/cache/test.cache.html b/src/Framework/View/cache/test.cache.html
deleted file mode 100644
index 37ec8cd9..00000000
--- a/src/Framework/View/cache/test.cache.html
+++ /dev/null
@@ -1,4 +0,0 @@
-<test><layout src="main"></layout>
-<h1>Willkommen!</h1>
-<p>Das ist deine Seite</p>
-</test>
diff --git a/src/Framework/View/templates/components/image.html b/src/Framework/View/templates/components/image.html
new file mode 100644
index 00000000..d46083e1
--- /dev/null
+++ b/src/Framework/View/templates/components/image.html
@@ -0,0 +1,6 @@
+<!-- AVIF -> WEBG -> JPEG -->
+
+<picture>
+    <!--<source srcset="{{ srcset }}" media="(min-width: 768px)" />-->
+    <img src="{{ src }}" alt="{{ alt }}" />
+</picture>
diff --git a/src/Framework/View/templates/components/imageslot.html b/src/Framework/View/templates/components/imageslot.html
new file mode 100644
index 00000000..0f93dde5
--- /dev/null
+++ b/src/Framework/View/templates/components/imageslot.html
@@ -0,0 +1,6 @@
+<picture>
+
+    <img src="/images/{{ image }}" alt="{{ alt }}" />
+
+</picture>
+
diff --git a/src/Framework/View/templates/designsystem.view.php b/src/Framework/View/templates/designsystem.view.php
new file mode 100644
index 00000000..18517962
--- /dev/null
+++ b/src/Framework/View/templates/designsystem.view.php
@@ -0,0 +1,55 @@
+<layout src="main"></layout>
+
+<h1>Michael Schiemer</h1>
+<h2>Heading 2</h2>
+<h3>Heading 3</h3>
+<h4>Heading 4</h4>
+<h5>Heading 5</h5>
+<h6>Heading 6</h6>
+
+<small>Small Text</small>
+
+<p>Some Paragraph and <a href="#">a Link</a>.</p>
+<p>Lorem ipsum dolor sit amet, consectetur adipisicing elit. Ab, ad aperiam beatae dolore, et fugiat magnam maiores minus neque, quaerat quos repellat repellendus rerum saepe sint temporibus veritatis vero voluptatum.</p>
+
+
+
+<form>
+    <h3>Form</h3>
+    <div>
+        <label for="email">Label
+        <svg height="64px" width="64px" version="1.1" id="Capa_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" viewBox="0 0 302.967 302.967" xml:space="preserve" fill="#000000" stroke="#000000" stroke-width="0.00302967"><g id="SVGRepo_bgCarrier" stroke-width="0"></g><g id="SVGRepo_tracerCarrier" stroke-linecap="round" stroke-linejoin="round"></g><g id="SVGRepo_iconCarrier"> <g> <g> <g> <path style="fill:#010002;" d="M151.483,302.967C67.956,302.967,0,235.017,0,151.483S67.956,0,151.483,0 s151.483,67.956,151.483,151.483S235.017,302.967,151.483,302.967z M151.483,24.416c-70.066,0-127.067,57.001-127.067,127.067 s57.001,127.067,127.067,127.067s127.067-57.001,127.067-127.067S221.555,24.416,151.483,24.416z"></path> </g> <g> <g> <path style="fill:#010002;" d="M116.586,118.12c1.795-4.607,4.297-8.588,7.511-11.961c3.225-3.389,7.114-6.016,11.667-7.898 c4.547-1.904,9.633-2.845,15.262-2.845c7.261,0,13.32,0.995,18.183,2.997c4.857,1.996,8.768,4.482,11.738,7.441 c2.964,2.97,5.091,6.168,6.369,9.584c1.273,3.432,1.915,6.636,1.915,9.595c0,4.901-0.642,8.947-1.915,12.118 c-1.278,3.171-2.866,5.88-4.759,8.131c-1.898,2.252-3.987,4.172-6.293,5.755c-2.295,1.588-4.471,3.171-6.516,4.759 c-2.045,1.583-3.862,3.394-5.445,5.439c-1.588,2.04-2.589,4.601-2.991,7.664v5.831H140.6v-6.908 c0.305-4.395,1.153-8.072,2.529-11.036c1.382-2.964,2.991-5.499,4.83-7.598c1.844-2.089,3.786-3.911,5.836-5.445 c2.04-1.539,3.927-3.073,5.673-4.591c1.73-1.545,3.144-3.225,4.221-5.069c1.071-1.833,1.556-4.15,1.452-6.908 c0-4.705-1.148-8.18-3.454-10.427c-2.295-2.257-5.493-3.378-9.589-3.378c-2.758,0-5.134,0.533-7.131,1.605 s-3.628,2.513-4.911,4.302c-1.278,1.795-2.225,3.894-2.834,6.288c-0.615,2.415-0.919,4.982-0.919,7.756h-22.55 C113.85,127.785,114.791,122.732,116.586,118.12z M162.536,183.938v23.616h-24.09v-23.616H162.536z"></path> </g> </g> </g> </g> </g></svg>
+        </label>
+        <span id="hint-name">Hint copy</span>
+        <span
+            id="email-error"
+            role="alert"
+            aria-live="polite">Not a valid Email-Address</span>
+        <input
+            type="email"
+            id="email"
+            name="email"
+            placeholder="Email@address.com"
+            required
+            aria-describedby="email-error"
+            aria-errormessage="email-error"
+        />
+
+
+    </div>
+</form>
+
+    <label>
+        Icon<input><input type="checkbox">
+    </label>
+    <button class="outline"><span>Icon</span></button>
+
+    <input type="submit" value="Submit"/>
+
+    <input type="reset" value="Reset"/>
+    <input type="button" value="Button"/>
+    <input type="button" value="Text" disabled/>
+    <input type="file" />
+
+
+<blockquote>Männer weinen ohne Tränen.</blockquote>
diff --git a/src/Framework/View/templates/epk.html b/src/Framework/View/templates/epk.view.php
similarity index 100%
rename from src/Framework/View/templates/epk.html
rename to src/Framework/View/templates/epk.view.php
diff --git a/src/Framework/View/templates/impressum.html b/src/Framework/View/templates/impressum.html
deleted file mode 100644
index 3a8ea6fc..00000000
--- a/src/Framework/View/templates/impressum.html
+++ /dev/null
@@ -1,3 +0,0 @@
-<layout src="main"/>
-<h1>Impressum!</h1>
-<p>Das ist deine Seite</p>
diff --git a/src/Framework/View/templates/impressum.view.php b/src/Framework/View/templates/impressum.view.php
new file mode 100644
index 00000000..103becb3
--- /dev/null
+++ b/src/Framework/View/templates/impressum.view.php
@@ -0,0 +1,227 @@
+<layout src="main"/>
+
+<section>
+    <form style="width: 500px" action="/newsletter/register" method="post">
+        <input type="email" name="email" placeholder="Email" />
+        <input type="checkbox" name="consens" id="consens"/>
+        <label for="consens">Ich stimme den Nutzungsbedingungen zu
+        (<a href="/datenschutz" target="_blank">Datenschutz</a>)
+        </label>
+        <button type="submit">Anmelden</button>
+    </form>
+</section>
+
+
+
+
+<section>
+<h1>Impressum!</h1>
+<p>Das ist deine Seite</p>
+
+    <a href="{{ url('datenschutz') }}">Datenschutz</a>
+
+    <hr>
+
+    {{ imageslot('slot1') }}
+</section>
+
+
+
+
+
+<style>
+
+    .image-fullwidth {
+        display: inline-block;
+        width: 100%;
+        height: 100%;
+        position: relative;
+        align-items: center;
+        justify-content: center;
+
+        &>div.overlay {
+            position: absolute;
+            z-index: 2;
+            text-align: center;
+
+            justify-self: center;
+            align-self: anchor-center;
+        }
+    }
+
+
+    picture {
+        display: flex;
+        width: 100%;
+
+        &>img {
+            scale: 1.1;
+            aspect-ratio: 21/9;
+            object-fit: cover;
+            width: 100%;
+        }
+    }
+
+</style>
+
+<div class="image-fullwidth">
+<picture>
+    <img src="https://localhost/images/AN1N9E1PAKFRBV1M_2f36ee4cde5b43e02c118f4b21e5a4904d0c13597b5c2f1127097b808080622d_original.jpg"/>
+</picture>
+<div class="overlay">
+    <p>The Overlay.</p>
+</div>
+
+
+</div>
+
+<style>
+    @keyframes parallax-slow {
+        from { transform: translateY(0); }
+        to { transform: translateY(-25vh); }
+    }
+
+    @keyframes parallax-medium {
+        from { transform: translateY(0); }
+        to { transform: translateY(-30vh); }
+    }
+
+
+    /* Basis-Setup */
+    .overlay-section {
+        position: relative;
+        height: min(100vw, 100vh);
+        overflow: hidden;
+    }
+
+    /* Picture Styling */
+    .background-picture {
+        position: absolute;
+        top: 0;
+        left: 0;
+
+        right: 0;
+        bottom: 0;
+        /*width: 100%;
+        height: 100%;*/
+        z-index: 1;
+
+        animation: parallax-slow linear;
+        animation-timeline: scroll(root);
+    }
+
+    .background-picture img {
+        width: 100%;
+        height: 100%;
+        object-fit: cover;
+
+        mask-image: linear-gradient(to bottom, rgba(0, 0, 0, 100%) 70%, rgba(0, 0, 0, 0) 95%);
+    }
+
+    /* Video Element Styling */
+    .background-video {
+        position: absolute;
+        top: 0;
+        left: 0;
+        width: 100%;
+        height: 100%;
+        z-index: 1;
+
+        animation: parallax-medium linear;
+        animation-timeline: scroll(root);
+    }
+
+    /* Video Styling */
+    .background-video video {
+        width: 100%;
+        height: 100%;
+        object-fit: cover;
+
+        mask-image: linear-gradient(to bottom, rgba(0, 0, 0, 100%) 50%, rgba(0, 0, 0, 0) 95%);
+
+        &:hover {
+            mask-image: none;
+        }
+    }
+
+    /* Overlay Positioning */
+    .overlay-bottom-right {
+        position: absolute;
+        bottom: 40px;
+        right: 40px;
+        z-index: 10;
+    }
+
+    .overlay-top-left {
+        position: absolute;
+        /*top: 40px;
+        left: 40px;*/
+        inset: 0;
+        padding: var(--content-padding);
+
+        z-index: 10;
+    }
+</style>
+
+<p>Test</p>
+
+
+<div class="overlay-section">
+
+    <picture class="background-picture">
+        <!--<source media="(max-width: 768px)" srcset="mobile.jpg">
+        <source media="(max-width: 1200px)" srcset="tablet.jpg">-->
+        <img src="https://localhost/images/AN1N9E1PAKFRBV1M_2f36ee4cde5b43e02c118f4b21e5a4904d0c13597b5c2f1127097b808080622d_original.jpg" alt="Background">
+    </picture>
+
+    <div class="overlay-top-left">
+        <h3>Überschrift</h3>
+        <p>Overlay Text.</p>
+    </div>
+
+</div>
+
+<section>
+    <h2>Hallo Welt</h2>
+    <p>Hier steht ein bisschen Text.</p>
+</section>
+
+
+<div class="overlay-section">
+    <div class="background-video">
+        <video autoplay muted loop playsinline>
+            <source src="https://localhost/videos/video1.mp4" type="video/mp4">
+            <source src="video.webm" type="video/webm">
+        </video>
+    </div>
+    <div class="overlay-top-left">
+        <p>Overlay Text.</p>
+    </div>
+</div>
+
+<section id="services">
+    <h2>Unsere Services</h2>
+    <p>Wir bieten eine Vielzahl von Dienstleistungen an, die darauf ausgerichtet sind, Ihr Unternehmen zum Erfolg zu führen.</p>
+    <div class="grid">
+        <div class="card">
+            <h3>Webentwicklung</h3>
+            <p>Moderne, responsive Websites, die auf allen Geräten perfekt funktionieren.</p>
+        </div>
+        <div class="card card--success">
+            <header>
+                <h3>App Development</h3>
+                <span role="status">Done</span>
+            </header>
+
+            <p>Native und Cross-Platform Apps für iOS und Android.</p>
+        </div>
+        <div class="card">
+            <h3>UI/UX Design</h3>
+            <p>Benutzerfreundliche Interfaces, die Ihre Nutzer begeistern.</p>
+        </div>
+        <div class="card">
+            <h3>Consulting</h3>
+            <p>Strategische Beratung für Ihre digitale Transformation.</p>
+        </div>
+    </div>
+</section>
diff --git a/src/Framework/View/templates/layouts/main.html b/src/Framework/View/templates/layouts/main.html
deleted file mode 100644
index b08564c4..00000000
--- a/src/Framework/View/templates/layouts/main.html
+++ /dev/null
@@ -1,73 +0,0 @@
-<!DOCTYPE html>
-<html lang="de">
-    <head>
-        <meta charset="UTF-8">
-        <meta name="viewport" content="width=device-width, initial-scale=1.0">
-        <title>{{ title }}</title>
-
-        <!-- Favicon (optional) -->
-        <link rel="icon" href="/favicon.ico" type="image/x-icon">
-
-        <!-- CSS Reset oder Normalize (optional) -->
-        <!-- <link rel="stylesheet" href="https://unpkg.com/modern-css-reset/dist/reset.min.css"> -->
-
-        <!-- Eigene Styles -->
-        <link rel="stylesheet" href="http://localhost:5173/assets/css/styles.css">
-
-        <!-- Open Graph / SEO Meta-Tags (optional) -->
-        <meta name="description" content="Kurzbeschreibung der Seite">
-        <meta property="og:title" content="Titel der Seite">
-        <meta property="og:description" content="Kurzbeschreibung der Seite">
-        <meta property="og:type" content="website">
-        <meta property="og:url" content="https://example.com">
-        <meta property="og:image" content="https://example.com/image.jpg">
-
-        <!-- Dark Mode Unterstützung (optional) -->
-        <meta name="color-scheme" content="light dark">
-    </head>
-    <body>
-        <header>
-            <div>
-                <a href="/" aria-label="Zur Startseite">
-                    Logo
-                </a>
-
-                <button aria-label="Navigation öffnen" aria-controls="Main Navigation" aria-expanded="false">☰</button>
-            </div>
-            <nav aria-label="Main Navigation">
-                <!-- Navigation -->
-            </nav>
-        </header>
-
-        <main>
-            <h1>Willkommen!</h1>
-            <p>Das ist der Hauptinhalt deiner Seite.</p>
-
-            <component name="alert" type="danger" message="Dies ist ein Hinweis" />
-
-            <component name="card" title="Titel" message="Nachricht" />
-
-
-            <!-- @dev START -->
-            <div>Dies ist nur für Entwickler sichtbar.</div>
-            <!-- @dev END -->
-            <div>Das ist öffentlich.</div>
-
-        </main>
-
-
-        <footer role="contentinfo">
-            <p>&copy; 2025 Michael Schiemer</p>
-
-            <nav aria-label="Footer Navigation">
-                <ul>
-                    <li><a href="/impressum">Impressum</a></li>
-                    <li><a href="/impressum">Datenschutz</a></li>
-                </ul>
-            </nav>
-        </footer>
-
-        <!-- Scripts -->
-        <script src="/assets/js/main.js" defer></script>
-    </body>
-</html>
diff --git a/src/Framework/View/templates/layouts/main.view.php b/src/Framework/View/templates/layouts/main.view.php
new file mode 100644
index 00000000..c940cffd
--- /dev/null
+++ b/src/Framework/View/templates/layouts/main.view.php
@@ -0,0 +1,95 @@
+<!DOCTYPE html>
+<html lang="de">
+    <head>
+        <meta charset="UTF-8">
+        <meta name="viewport" content="width=device-width, initial-scale=1.0">
+        <title>{{ title }} | Michael Schiemer</title>
+
+        <!-- Favicon (optional) -->
+        <link rel="icon" href="/favicon.ico" type="image/x-icon">
+
+        <!-- CSS Reset oder Normalize (optional) -->
+        <!-- <link rel="stylesheet" href="https://unpkg.com/modern-css-reset/dist/reset.min.css"> -->
+
+        <!-- Eigene Styles -->
+        <!--<link rel="stylesheet" href="http://localhost:5173/assets/css/styles.css">-->
+
+        <!-- Open Graph / SEO Meta-Tags (optional) -->
+        <meta name="description" content="Kurzbeschreibung der Seite">
+        <meta property="og:title" content="{{ title }}">
+        <meta property="og:description" content="Kurzbeschreibung der Seite">
+        <meta property="og:type" content="website">
+        <meta property="og:url" content="https://example.com">
+        <meta property="og:image" content="https://example.com/image.jpg">
+
+        <!-- Dark Mode Unterstützung (optional) -->
+        <meta name="color-scheme" content="light dark">
+    </head>
+    <body class="grainy">
+        <div class="noise-overlay"></div>
+
+        <a href="#pageTitle" class="skip-link">Skip to content</a>
+
+        <!-- Header -->
+            <header view-transition-name="site-header">
+                <div>
+                <a href="/" aria-label="Zur Startseite">MS</a>
+
+                <button popovertarget="mypopover"
+                        popovertargetaction="show"
+                        aria-label="Menü öffnen"
+                        aria-controls="Main Navigation"
+                        aria-expanded="false"
+                        id="menu-toggle"
+                >☰</button>
+                </div>
+            </header>
+
+        <div class="backdrop"></div>
+
+        <aside id="sidebar" view-transition-name="sidebar">
+
+            <nav aria-label="Hauptnavigation" id="mypopover">
+                <!-- Navigation -->
+                <menu>
+                    <li><a href="/">Startseite</a></li>
+                    <li><a href="/impressum">Impressum</a></li>
+                    <li><a href="/kontakt">Kontakt</a></li>
+                </menu>
+            </nav>
+        </aside>
+
+
+
+            <!--<div class="page-container"  tabindex="-1" id="pageTitle" style="outline: none">-->
+
+                <main view-transition-name="main-content">
+                    <component name="alert" type="danger" message="Dies ist ein Hinweis" />
+
+                    <component name="card" title="Titel" message="Nachricht" />
+
+
+                    <!-- @dev START -->
+                    <div>Dies ist nur für Entwickler sichtbar.</div>
+                    <!-- @dev END -->
+                    <div>Das ist öffentlich.</div>
+
+                </main>
+
+
+            <!--</div>-->
+
+            <footer role="contentinfo" view-transition-name="site-footer">
+
+
+                <nav aria-label="Footer Navigation">
+                    <menu class="footer-nav">
+                        <li><a href="/impressum">Impressum</a></li>
+                        <li><a href="/datenschutz">Datenschutz</a></li>
+                        <li><a href="/sitemap">Sitemap</a></li>
+                    </menu>
+                </nav>
+                <p>&copy; 2025 Michael Schiemer. Alle Rechte vorbehalten.</p>
+            </footer>
+    </body>
+</html>
diff --git a/src/Framework/View/templates/test.html b/src/Framework/View/templates/test.html
deleted file mode 100644
index e27c4af1..00000000
--- a/src/Framework/View/templates/test.html
+++ /dev/null
@@ -1,3 +0,0 @@
-<layout src="main"/>
-<h1>Willkommen!</h1>
-<p>Das ist deine Seite</p>
diff --git a/src/Framework/View/templates/test.view.php b/src/Framework/View/templates/test.view.php
new file mode 100644
index 00000000..4e958b4c
--- /dev/null
+++ b/src/Framework/View/templates/test.view.php
@@ -0,0 +1,157 @@
+<layout src="main"/>
+
+
+<video src="https://localhost/videos/video1.mp4" autoplay loop muted></video>
+
+
+
+<section class="hero" data-scroll-step="1">
+    <!--<picture>
+        &lt;!&ndash;<source srcset="/assets/images/hero.avif" type="image/avif">
+        <source srcset="assets/images/hero.webp" type="image/webp">&ndash;&gt;
+        <img src="/assets/images/hero_small.jpg" alt="" aria-hidden="true" />
+    </picture>-->
+
+    <component name="alert" type="info" message="Hilfe!"></component>
+
+    <component
+        name="image"
+        src="/assets/images/hero.jpg"
+        srcset="/assets/images/hero.webp 768w"
+        alt="Ein Beispielbild">
+    </component>
+
+
+    <component name="card" title="Wichtige Information" image="/assets/images/hero_small.jpg" message="ERROR!">
+        Hier steht der Inhalt der Karte
+    </component>
+
+
+    <h1 class="zoomed">Willkommen!</h1>
+
+    <h2>Überschrift</h2>
+    <p>Das ist deine Seite.
+    Hier steht noch viel mehr Text.
+    Das ist direkt noch eine neue Zeile.</p>
+    <button>Test</button>
+    <button class="secondary">Secondary</button>
+    <button class="outline">Outline</button>
+</section>
+
+<form action="/newsletter/register" method="post">
+    <input type="text" name="name" placeholder="Name"/>
+    <input type="email" name="email" placeholder="Email"/>
+    <input type="checkbox" name="consent" />
+    <input type="submit" />
+</form>
+
+
+<section class="fade">
+    <div>
+        <h2>Über mich</h2>
+        <p>Textinhalt...</p>
+    </div>
+    <p>Textinhalt...</p>
+</section>
+
+<section class="fade" data-scroll-step="2">
+    <div>
+        <h2>Über mich</h2>
+        <p>Textinhalt...</p>
+    </div>
+    <p>Textinhalt...</p>
+</section>
+
+<blockquote class="zoomed">
+    Das ist ein Zitat.
+</blockquote>
+
+<section>
+    <div class="fade">
+        <h2>Ich parallaxe</h2>
+        <p>Lorem ipsum dolor sit amet, consectetur adipisicing elit. A accusantium amet, asperiores delectus, dolores dolorum in ipsam libero, magnam neque nobis nostrum perferendis perspiciatis quae recusandae reprehenderit similique temporibus ut!</p>
+    </div>
+</section>
+
+<section data-scroll-step="3">
+    <div class="fade">
+        <h2>Über mich</h2>
+        <p>Textinhalt...</p>
+    </div>
+</section>
+
+<div data-sticky-container>
+    <div data-sticky-step>Kapitel 1</div>
+    <div data-sticky-step>Kapitel 2</div>
+    <div data-sticky-step>Kapitel 3</div>
+</div>
+
+
+<section class="hero">
+    <div class="fade">
+        <h2>Über mich</h2>
+        <p>Textinhalt...</p>
+    </div>
+</section>
+
+<div class="loop-container">
+    <div data-scroll-loop data-scroll-speed="0.25">
+        <img src="" />
+        <img src="" aria-hidden="true" />
+        Some Scoll Loop
+    </div>
+</div>
+
+<div data-scroll-loop data-scroll-type="rotate" data-scroll-speed="0.5">
+    🔄
+</div>
+
+<section class="hero" data-parallax data-parallax-speed="0.5">
+    <div class="fade">
+        <h2>Über mich</h2>
+        <p>Textinhalt...</p>
+    </div>
+</section>
+
+<div data-scroll-loop data-scroll-speed="0.25">
+    Hallo Welt
+</div>
+
+<div data-scroll-loop data-scroll-type="scale" data-loop-pause="true">
+    Pausierbar?
+</div>
+
+<section class="hero">
+    <div class="fade">
+        <h2>Über mich</h2>
+        <p>Textinhalt...</p>
+    </div>
+</section>
+
+
+<div data-sticky-fade data-scroll-dir="up">
+    Ich werde sichtbar, wenn ich in den Viewport scrolle.
+</div>
+
+
+<section class="hero">
+    <div class="fade">
+        <h2>Über mich</h2>
+        <p>Textinhalt...</p>
+    </div>
+</section>
+
+
+<section class="hero">
+    <div class="fade">
+        <h2>Über mich</h2>
+        <p>Textinhalt...</p>
+    </div>
+</section>
+
+
+<button command="show-modal" commandfor="my-dialog">Sesam, öffne dich!</button>
+
+<dialog id="my-dialog" closedby="any">
+    Ich bin eine Dialogbox.
+</dialog>>
diff --git a/src/Framework/Worker/Every.php b/src/Framework/Worker/Every.php
new file mode 100644
index 00000000..624de52f
--- /dev/null
+++ b/src/Framework/Worker/Every.php
@@ -0,0 +1,19 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Worker;
+
+final readonly class Every
+{
+    public function __construct(
+        public int $days = 0,
+        public int $hours = 0,
+        public int $minutes = 0,
+        public int $seconds = 0,
+    ) {}
+
+    public function toSeconds(): int
+    {
+        return $this->days * 86400 + $this->hours * 3600 + $this->minutes * 60 + $this->seconds;
+    }
+}
diff --git a/src/Framework/Worker/Schedule.php b/src/Framework/Worker/Schedule.php
new file mode 100644
index 00000000..71b39576
--- /dev/null
+++ b/src/Framework/Worker/Schedule.php
@@ -0,0 +1,14 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Worker;
+
+use Attribute;
+
+#[\Attribute(Attribute::TARGET_CLASS|Attribute::IS_REPEATABLE)]
+final class Schedule
+{
+    public function __construct(
+        public Every $at,
+    ) {}
+}
diff --git a/src/Framework/Worker/Worker.php b/src/Framework/Worker/Worker.php
new file mode 100644
index 00000000..6414b710
--- /dev/null
+++ b/src/Framework/Worker/Worker.php
@@ -0,0 +1,131 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Worker;
+
+use App\Framework\CommandBus\CommandBus;
+use App\Framework\Console\ConsoleColor;
+use App\Framework\Console\ConsoleOutput;
+use App\Framework\DateTime\Clock;
+use App\Framework\DateTime\Timer;
+use App\Framework\DI\Container;
+use App\Framework\Queue\FileQueue;
+use App\Framework\Queue\Queue;
+
+final class Worker
+{
+    private int $processedJobs = 0;
+    private int $startTime;
+    private bool $running = false;
+    private readonly Timer $timer;
+    private readonly Clock $clock;
+
+    public function __construct(
+        private readonly Container     $container,
+        private readonly Queue     $queue,
+        private readonly CommandBus    $commandBus,
+        private readonly ConsoleOutput $output
+    )
+    {
+        $this->timer = $this->container->get(Timer::class);
+        $this->clock = $this->container->get(Clock::class);
+
+        $this->startTime = $this->clock->time();
+    }
+
+    public function start(): void
+    {
+        $this->running = true;
+        $this->output->writeLine('🚀 Worker gestartet', ConsoleColor::BRIGHT_GREEN);
+
+        while ($this->running) {
+            $this->processJob();
+        }
+    }
+
+    public function stop(): void
+    {
+        $this->running = false;
+        $this->output->writeLine('🛑 Worker gestoppt', ConsoleColor::BRIGHT_RED);
+    }
+
+    private function processJob(): void
+    {
+        $job = $this->queue->pop();
+
+        if ($job) {
+            $this->handleJob($job);
+        } else {
+            $this->idle();
+        }
+    }
+
+    private array $processedJobHashes = [];
+
+    private function handleJob(object $job): void
+    {
+        try {
+            $this->processedJobs++;
+            $jobClass = $job::class;
+
+            // Job-Hash für Duplicate-Detection
+            $jobHash = md5(serialize($job));
+
+            if (isset($this->processedJobHashes[$jobHash])) {
+                $this->output->writeLine("⚠️  DUPLICATE JOB erkannt #{$this->processedJobs}: " . $jobClass, ConsoleColor::BRIGHT_RED);
+                $this->output->writeLine("   Bereits verarbeitet: " . $this->processedJobHashes[$jobHash] . " mal", ConsoleColor::RED);
+                $this->processedJobHashes[$jobHash]++;
+
+                // Nach 5 Duplikaten Worker stoppen
+                if ($this->processedJobHashes[$jobHash] > 5) {
+                    $this->output->writeLine("🛑 Zu viele Duplikate - Worker wird gestoppt", ConsoleColor::BRIGHT_RED);
+                    $this->stop();
+                    return;
+                }
+            } else {
+                $this->processedJobHashes[$jobHash] = 1;
+            }
+
+            $this->output->writeLine("🔄 Verarbeite Job #{$this->processedJobs}: " . $jobClass, ConsoleColor::BRIGHT_YELLOW);
+
+            $this->commandBus->dispatch($job);
+
+            $this->output->writeLine("✅ Job #{$this->processedJobs} erfolgreich verarbeitet", ConsoleColor::BRIGHT_GREEN);
+            $this->showStatistics();
+        } catch (\Throwable $e) {
+            $this->handleError($job, $e);
+        }
+    }
+
+    private function handleError(object $job, \Throwable $e): void
+    {
+        $this->output->writeLine("❌ Fehler beim Verarbeiten von Job #{$this->processedJobs}:", ConsoleColor::BRIGHT_RED);
+        $this->output->writeLine('   Typ: ' . $job::class, ConsoleColor::RED);
+        $this->output->writeLine('   Fehler: ' . $e->getMessage(), ConsoleColor::RED);
+        $this->output->writeLine('   Datei: ' . $e->getFile() . ':' . $e->getLine(), ConsoleColor::RED);
+
+        error_log('Worker Error: ' . $e->getMessage());
+    }
+
+    private function showStatistics(): void
+    {
+        $runtime = $this->clock->time() - $this->startTime;
+        $avgJobsPerSecond = $runtime > 0 ? round($this->processedJobs / $runtime, 2) : 0;
+        $this->output->writeLine("📊 Statistiken: {$this->processedJobs} Jobs | Laufzeit: {$runtime}s | ⌀ {$avgJobsPerSecond} Jobs/s", ConsoleColor::BRIGHT_CYAN);
+        $this->output->newLine();
+    }
+
+    private function idle(): void
+    {
+        static $idleCycles = 0;
+        $idleCycles++;
+
+        if ($idleCycles % 100 === 0) {
+            $runtime = $this->clock->time() - $this->startTime;
+            $this->output->writeLine("💓 Heartbeat: {$this->processedJobs} Jobs verarbeitet | Laufzeit: {$runtime}s", ConsoleColor::BRIGHT_MAGENTA);
+        }
+
+        # usleep(100_000);
+        $this->timer->msleep(100);
+    }
+}
diff --git a/src/Infrastructure/AI/AiHandlerFactory.php b/src/Infrastructure/AI/AiHandlerFactory.php
new file mode 100644
index 00000000..1b73bec3
--- /dev/null
+++ b/src/Infrastructure/AI/AiHandlerFactory.php
@@ -0,0 +1,124 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Infrastructure\AI;
+
+use App\Domain\AI\AiModel;
+use App\Domain\AI\AiProvider;
+use App\Domain\AI\AiQueryHandlerInterface;
+use App\Infrastructure\AI\GPT4All\Gpt4AllQueryHandler;
+use App\Infrastructure\AI\Ollama\OllamaQueryHandler;
+use App\Infrastructure\AI\OpenAI\OpenAiQueryHandler;
+use App\Framework\HttpClient\HttpClient;
+use InvalidArgumentException;
+
+final readonly class AiHandlerFactory
+{
+    public function __construct(
+        private HttpClient $httpClient,
+        private string $openAiApiKey = '',
+        private string $gpt4AllApiUrl = 'http://host.docker.internal:4891',
+        private string $ollamaApiUrl = 'http://host.docker.internal:11434'
+    ) {}
+
+    public function createForModel(AiModel $model): AiQueryHandlerInterface
+    {
+        return match($model->getProvider()) {
+            AiProvider::OPENAI => new OpenAiQueryHandler(
+                $this->httpClient,
+                $this->openAiApiKey
+            ),
+            AiProvider::GPT4ALL => new Gpt4AllQueryHandler(
+                $this->httpClient,
+                $this->gpt4AllApiUrl
+            ),
+            AiProvider::OLLAMA => new OllamaQueryHandler(
+                $this->httpClient,
+                $this->ollamaApiUrl
+            ),
+            default => throw new InvalidArgumentException("Unsupported AI provider: {$model->getProvider()->value}")
+        };
+    }
+
+    public function createForProvider(AiProvider $provider): AiQueryHandlerInterface
+    {
+        return match($provider) {
+            AiProvider::OPENAI => new OpenAiQueryHandler(
+                $this->httpClient,
+                $this->openAiApiKey
+            ),
+            AiProvider::GPT4ALL => new Gpt4AllQueryHandler(
+                $this->httpClient,
+                $this->gpt4AllApiUrl
+            ),
+            AiProvider::OLLAMA => new OllamaQueryHandler(
+                $this->httpClient,
+                $this->ollamaApiUrl
+            ),
+            default => throw new InvalidArgumentException("Unsupported AI provider: {$provider->value}")
+        };
+    }
+
+    public function getAvailableProviders(): array
+    {
+        $providers = [];
+
+        // OpenAI ist verfügbar wenn API Key gesetzt ist
+        if (!empty($this->openAiApiKey)) {
+            $providers[] = AiProvider::OPENAI;
+        }
+
+        // GPT4All prüfen
+        $gpt4allHandler = new Gpt4AllQueryHandler($this->httpClient, $this->gpt4AllApiUrl);
+        if ($gpt4allHandler->isAvailable()) {
+            $providers[] = AiProvider::GPT4ALL;
+        }
+
+        // Ollama prüfen
+        $ollamaHandler = new OllamaQueryHandler($this->httpClient, $this->ollamaApiUrl);
+        if ($ollamaHandler->isAvailable()) {
+            $providers[] = AiProvider::OLLAMA;
+        }
+
+        return $providers;
+    }
+
+    public function getAvailableModels(): array
+    {
+        $availableProviders = $this->getAvailableProviders();
+        $providerSet = array_flip($availableProviders);
+        $availableModels = [];
+
+        foreach (AiModel::cases() as $model) {
+            if (isset($providerSet[$model->getProvider()->value])) {
+                // Für Ollama zusätzlich prüfen ob das spezifische Modell verfügbar ist
+                if ($model->getProvider() === AiProvider::OLLAMA) {
+                    $ollamaHandler = new OllamaQueryHandler($this->httpClient, $this->ollamaApiUrl);
+                    $ollamaModels = $ollamaHandler->getAvailableModels();
+                    if (in_array($model->value, $ollamaModels, true)) {
+                        $availableModels[] = $model;
+                    }
+                } else {
+                    $availableModels[] = $model;
+                }
+            }
+        }
+
+        return $availableModels;
+    }
+
+    public function isProviderAvailable(AiProvider $provider): bool
+    {
+        return in_array($provider, $this->getAvailableProviders(), true);
+    }
+
+    public function getOllamaAvailableModels(): array
+    {
+        if (!$this->isProviderAvailable(AiProvider::OLLAMA)) {
+            return [];
+        }
+
+        $ollamaHandler = new OllamaQueryHandler($this->httpClient, $this->ollamaApiUrl);
+        return $ollamaHandler->getAvailableModels();
+    }
+}
diff --git a/src/Infrastructure/AI/AiService.php b/src/Infrastructure/AI/AiService.php
new file mode 100644
index 00000000..19a262fa
--- /dev/null
+++ b/src/Infrastructure/AI/AiService.php
@@ -0,0 +1,90 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Infrastructure\AI;
+
+use App\Domain\AI\AiModel;
+use App\Domain\AI\AiProvider;
+use App\Domain\AI\AiQuery;
+use App\Domain\AI\AiResponse;
+use App\Domain\AI\Exception\AiProviderUnavailableException;
+
+final readonly class AiService
+{
+    public function __construct(
+        private AiHandlerFactory $handlerFactory
+    ) {}
+
+    public function query(
+        string $message,
+        AiModel $model = AiModel::GPT_35_TURBO,
+        array $messages = [],
+        float $temperature = 0.7,
+        ?int $maxTokens = null
+    ): AiResponse {
+        $query = new AiQuery($message, $model, $messages, $temperature, $maxTokens);
+        $handler = $this->handlerFactory->createForModel($model);
+
+        return $handler($query);
+    }
+
+    public function queryWithFallback(
+        string $message,
+        AiModel $preferredModel = AiModel::GPT_35_TURBO,
+        array $messages = [],
+        float $temperature = 0.7,
+        ?int $maxTokens = null
+    ): AiResponse {
+        // Zuerst bevorzugtes Modell versuchen
+        try {
+            return $this->query($message, $preferredModel, $messages, $temperature, $maxTokens);
+        } catch (AiProviderUnavailableException $e) {
+            // Fallback auf verfügbare Modelle
+            $availableModels = $this->handlerFactory->getAvailableModels();
+
+            if (empty($availableModels)) {
+                throw new AiProviderUnavailableException(
+                    $preferredModel->getProvider(),
+                    'Keine AI-Provider verfügbar. Prüfen Sie Ihre Konfiguration.'
+                );
+            }
+
+            // Erstes verfügbares Modell verwenden
+            $fallbackModel = $availableModels[0];
+            return $this->query($message, $fallbackModel, $messages, $temperature, $maxTokens);
+        }
+    }
+
+    public function queryWithConversation(
+        array $messages,
+        AiModel $model = AiModel::GPT_35_TURBO,
+        float $temperature = 0.7,
+        ?int $maxTokens = null
+    ): AiResponse {
+        // Für Gespräche verwenden wir eine leere Nachricht, da die messages bereits alles enthalten
+        $query = new AiQuery('', $model, $messages, $temperature, $maxTokens);
+        $handler = $this->handlerFactory->createForModel($model);
+
+        return $handler($query);
+    }
+
+    public function getAvailableProviders(): array
+    {
+        return $this->handlerFactory->getAvailableProviders();
+    }
+
+    public function getAvailableModels(): array
+    {
+        return $this->handlerFactory->getAvailableModels();
+    }
+
+    public function isProviderAvailable(AiProvider $provider): bool
+    {
+        return $this->handlerFactory->isProviderAvailable($provider);
+    }
+
+    public function getOllamaAvailableModels(): array
+    {
+        return $this->handlerFactory->getOllamaAvailableModels();
+    }
+}
diff --git a/src/Infrastructure/AI/GPT4All/Gpt4AllQueryHandler.php b/src/Infrastructure/AI/GPT4All/Gpt4AllQueryHandler.php
new file mode 100644
index 00000000..4a432fa0
--- /dev/null
+++ b/src/Infrastructure/AI/GPT4All/Gpt4AllQueryHandler.php
@@ -0,0 +1,89 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Infrastructure\AI\GPT4All;
+
+use App\Domain\AI\AiQuery;
+use App\Domain\AI\AiQueryHandlerInterface;
+use App\Domain\AI\AiResponse;
+use App\Domain\AI\Exception\AiProviderUnavailableException;
+use App\Domain\AI\AiProvider;
+use App\Framework\Http\Headers;
+use App\Framework\Http\Method;
+use App\Framework\HttpClient\ClientRequest;
+use App\Framework\HttpClient\HttpClient;
+use App\Framework\HttpClient\Exception\CurlExecutionFailed;
+
+final readonly class Gpt4AllQueryHandler implements AiQueryHandlerInterface
+{
+    public function __construct(
+        private HttpClient $httpClient,
+        private string $gpt4AllApiUrl = 'http://host.docker.internal:4891'
+    ) {}
+
+    public function isAvailable(): bool
+    {
+        try {
+            $healthUrl = $this->gpt4AllApiUrl . '/health';
+            $request = ClientRequest::json(Method::GET, $healthUrl, []);
+
+            $this->httpClient->send($request);
+            return true;
+        } catch (CurlExecutionFailed $e) {
+            return false;
+        } catch (\Exception $e) {
+            return false;
+        }
+    }
+
+    public function __invoke(AiQuery $query): AiResponse
+    {
+        if (!$this->isAvailable()) {
+            throw new AiProviderUnavailableException(
+                AiProvider::GPT4ALL,
+                "GPT4All Server ist nicht erreichbar unter {$this->gpt4AllApiUrl}. " .
+                "Stellen Sie sicher, dass GPT4All läuft oder verwenden Sie einen anderen Provider."
+            );
+        }
+
+        $url = $this->gpt4AllApiUrl . '/v1/chat/completions';
+
+        $data = [
+            'model' => $query->model->value,
+            'messages' => $query->messages !== []
+                ? $query->messages
+                : [['role' => 'user', 'content' => $query->message]],
+            'temperature' => $query->temperature,
+        ];
+
+        if ($query->maxTokens !== null) {
+            $data['max_tokens'] = $query->maxTokens;
+        }
+
+        try {
+            $request = ClientRequest::json(
+                Method::POST,
+                $url,
+                $data
+            )->with([
+                'headers' => new Headers()
+                    ->with('Content-Type', 'application/json')
+            ]);
+
+            $response = $this->httpClient->send($request);
+            $body = json_decode($response->body, true);
+
+            return new AiResponse(
+                content: $body['choices'][0]['message']['content'] ?? '',
+                provider: 'gpt4all',
+                model: $query->model->value,
+                tokensUsed: $body['usage']['total_tokens'] ?? null
+            );
+        } catch (CurlExecutionFailed $e) {
+            throw new AiProviderUnavailableException(
+                AiProvider::GPT4ALL,
+                "Verbindung zu GPT4All fehlgeschlagen: " . $e->getMessage()
+            );
+        }
+    }
+}
diff --git a/src/Infrastructure/AI/Ollama/OllamaQueryHandler.php b/src/Infrastructure/AI/Ollama/OllamaQueryHandler.php
new file mode 100644
index 00000000..9c1a4d41
--- /dev/null
+++ b/src/Infrastructure/AI/Ollama/OllamaQueryHandler.php
@@ -0,0 +1,140 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Infrastructure\AI\Ollama;
+
+use App\Domain\AI\AiQuery;
+use App\Domain\AI\AiQueryHandlerInterface;
+use App\Domain\AI\AiResponse;
+use App\Domain\AI\Exception\AiProviderUnavailableException;
+use App\Domain\AI\AiProvider;
+use App\Framework\Http\Headers;
+use App\Framework\Http\Method;
+use App\Framework\HttpClient\ClientOptions;
+use App\Framework\HttpClient\ClientRequest;
+use App\Framework\HttpClient\HttpClient;
+use App\Framework\HttpClient\Exception\CurlExecutionFailed;
+
+final readonly class OllamaQueryHandler implements AiQueryHandlerInterface
+{
+    public function __construct(
+        private HttpClient $httpClient,
+        private string $ollamaApiUrl = 'http://host.docker.internal:11434'
+    ) {}
+
+    public function isAvailable(): bool
+    {
+        #debug(file_get_contents('http://host.docker.internal:11434/api/tags'));
+
+        try {
+            $healthUrl = $this->ollamaApiUrl . '/api/tags';
+            $request = new ClientRequest(
+                method: Method::GET,
+                url: $healthUrl,
+                headers: new Headers(),
+                body: '',
+                options: new ClientOptions(
+                    timeout       : 360,
+                    verifySsl     : false,
+                    connectTimeout: 60
+                )
+            );
+
+            $this->httpClient->send($request);
+
+            return true;
+        } catch (CurlExecutionFailed $e) {
+            return false;
+        } catch (\Exception $e) {
+            return false;
+        }
+    }
+
+    public function getAvailableModels(): array
+    {
+        try {
+            $tagsUrl = $this->ollamaApiUrl . '/api/tags';
+            $request = ClientRequest::json(Method::GET, $tagsUrl, []);
+
+            $response = $this->httpClient->send($request);
+            $body = json_decode($response->body, true);
+
+            return array_map(fn($model) => $model['name'], $body['models'] ?? []);
+        } catch (\Exception $e) {
+            return [];
+        }
+    }
+
+    public function __invoke(AiQuery $query): AiResponse
+    {
+        if (!$this->isAvailable()) {
+            throw new AiProviderUnavailableException(
+                AiProvider::OLLAMA,
+                "Ollama Server ist nicht erreichbar unter {$this->ollamaApiUrl}. " .
+                "Stellen Sie sicher, dass Ollama läuft oder verwenden Sie einen anderen Provider."
+            );
+        }
+
+        // Prüfen ob das Modell verfügbar ist
+        $availableModels = $this->getAvailableModels();
+        $modelExists = in_array($query->model->value, $availableModels, true);
+
+        if (!$modelExists) {
+            throw new AiProviderUnavailableException(
+                AiProvider::OLLAMA,
+                "Modell '{$query->model->value}' ist nicht verfügbar. " .
+                "Verfügbare Modelle: " . implode(', ', $availableModels) . ". " .
+                "Installieren Sie das Modell mit: ollama pull {$query->model->value}"
+            );
+        }
+
+        $url = $this->ollamaApiUrl . '/api/chat';
+
+        // Ollama verwendet ein anderes Format als OpenAI
+        $messages = $query->messages !== []
+            ? $query->messages
+            : [['role' => 'user', 'content' => $query->message]];
+
+        $data = [
+            'model' => $query->model->value,
+            'messages' => $messages,
+            'stream' => false, // Keine Streaming-Antwort
+            'options' => [
+                'temperature' => $query->temperature,
+            ]
+        ];
+
+        if ($query->maxTokens !== null) {
+            $data['options']['num_predict'] = $query->maxTokens;
+        }
+
+        try {
+            $request = ClientRequest::json(
+                Method::POST,
+                $url,
+                $data
+            )->with([
+                'headers' => new Headers()
+                    ->with('Content-Type', 'application/json')
+            ]);
+
+            $response = $this->httpClient->send($request);
+            $body = json_decode($response->body, true);
+
+            // Ollama API Antwortformat ist anders als OpenAI
+            $content = $body['message']['content'] ?? '';
+
+            return new AiResponse(
+                content: $content,
+                provider: 'ollama',
+                model: $query->model->value,
+                tokensUsed: $body['eval_count'] ?? null // Ollama verwendet eval_count für Token-Zählung
+            );
+        } catch (CurlExecutionFailed $e) {
+            throw new AiProviderUnavailableException(
+                AiProvider::OLLAMA,
+                "Verbindung zu Ollama fehlgeschlagen: " . $e->getMessage()
+            );
+        }
+    }
+}
diff --git a/src/Infrastructure/AI/OpenAI/OpenAiQueryHandler.php b/src/Infrastructure/AI/OpenAI/OpenAiQueryHandler.php
new file mode 100644
index 00000000..8e840ec9
--- /dev/null
+++ b/src/Infrastructure/AI/OpenAI/OpenAiQueryHandler.php
@@ -0,0 +1,56 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Infrastructure\AI\OpenAI;
+
+use App\Domain\AI\AiQuery;
+use App\Domain\AI\AiQueryHandlerInterface;
+use App\Domain\AI\AiResponse;
+use App\Framework\Http\Headers;
+use App\Framework\Http\Method;
+use App\Framework\HttpClient\ClientRequest;
+use App\Framework\HttpClient\HttpClient;
+
+final readonly class OpenAiQueryHandler implements AiQueryHandlerInterface
+{
+    public function __construct(
+        private HttpClient $httpClient,
+        private string $openAiApiKey = ""
+    ) {}
+
+    public function __invoke(AiQuery $query): AiResponse
+    {
+        $url = 'https://api.openai.com/v1/chat/completions';
+
+        $data = [
+            'model' => $query->model->value,
+            'messages' => $query->messages !== []
+                ? $query->messages
+                : [['role' => 'user', 'content' => $query->message]],
+            'temperature' => $query->temperature,
+        ];
+
+        if ($query->maxTokens !== null) {
+            $data['max_tokens'] = $query->maxTokens;
+        }
+
+        $request = ClientRequest::json(
+            Method::POST,
+            $url,
+            $data
+        )->with([
+            'headers' => new Headers()
+                ->with('Authorization', 'Bearer ' . $this->openAiApiKey)
+        ]);
+
+        $response = $this->httpClient->send($request);
+        $body = json_decode($response->body, true);
+
+        return new AiResponse(
+            content: $body['choices'][0]['message']['content'] ?? '',
+            provider: 'openai',
+            model: $query->model->value,
+            tokensUsed: $body['usage']['total_tokens'] ?? null
+        );
+    }
+}
diff --git a/src/Infrastructure/Api/GitHubClient.php b/src/Infrastructure/Api/GitHubClient.php
new file mode 100644
index 00000000..0b4bf273
--- /dev/null
+++ b/src/Infrastructure/Api/GitHubClient.php
@@ -0,0 +1,77 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Infrastructure\Api;
+
+use App\Framework\Api\ApiRequestTrait;
+use App\Framework\Http\Method;
+use App\Framework\HttpClient\AuthConfig;
+use App\Framework\HttpClient\ClientOptions;
+use App\Framework\HttpClient\CurlHttpClient;
+use App\Framework\HttpClient\HttpClient;
+
+final class GitHubClient
+{
+    use ApiRequestTrait;
+
+    public function __construct(
+        string $token,
+        ?HttpClient $httpClient = null
+    ) {
+        $this->baseUrl = 'https://api.github.com';
+        $this->defaultOptions = new ClientOptions(
+            auth: AuthConfig::bearer($token)
+        );
+        $this->httpClient = $httpClient ?? new CurlHttpClient();
+
+        // GitHub API spezifische Header setzen
+        $this->defaultOptions = new ClientOptions(
+            auth: AuthConfig::bearer($token),
+            userAgent: 'PHP-App-Framework'
+        );
+    }
+
+    /**
+     * Holt Repositories eines Benutzers
+     */
+    public function getUserRepositories(string $username): array
+    {
+        $response = $this->sendRequest(
+            method: Method::GET,
+            endpoint: "users/{$username}/repos"
+        );
+
+        return $this->decodeJson($response);
+    }
+
+    /**
+     * Erstellt ein neues Repository
+     */
+    public function createRepository(string $name, string $description = '', bool $isPrivate = false): array
+    {
+        $response = $this->sendRequest(
+            method: Method::POST,
+            endpoint: 'user/repos',
+            data: [
+                'name' => $name,
+                'description' => $description,
+                'private' => $isPrivate
+            ]
+        );
+
+        return $this->decodeJson($response);
+    }
+
+    /**
+     * Ruft Informationen zu einem bestimmten Repository ab
+     */
+    public function getRepository(string $owner, string $repo): array
+    {
+        $response = $this->sendRequest(
+            method: Method::GET,
+            endpoint: "repos/{$owner}/{$repo}"
+        );
+
+        return $this->decodeJson($response);
+    }
+}
diff --git a/src/Infrastructure/Api/README.md b/src/Infrastructure/Api/README.md
new file mode 100644
index 00000000..fd20913a
--- /dev/null
+++ b/src/Infrastructure/Api/README.md
@@ -0,0 +1,95 @@
+# API-Client Framework
+
+Diese Komponente bietet eine einheitliche Schnittstelle für die Kommunikation mit verschiedenen externen APIs.
+
+## Verfügbare API-Clients
+
+### RapidMailClient
+
+Integration mit der RapidMail API für E-Mail-Marketing:
+
+```php
+$client = new RapidMailClient(
+    ApiConfig::RAPIDMAIL_USERNAME->value,
+    ApiConfig::RAPIDMAIL_PASSWORD->value
+);
+
+// Abonnent zur Liste hinzufügen
+$result = $client->addRecipient('user@example.com', ApiConfig::getRapidmailListId());
+```
+
+### ShopifyClient
+
+Integration mit der Shopify REST API für E-Commerce:
+
+```php
+$client = new ShopifyClient(
+    ApiConfig::SHOPIFY_SHOP_DOMAIN->value,
+    ApiConfig::SHOPIFY_ACCESS_TOKEN->value,
+    ApiConfig::SHOPIFY_API_VERSION->value
+);
+
+// Produkte abrufen
+$products = $client->getProducts(['limit' => 50]);
+
+// Einzelnes Produkt abrufen
+$product = $client->getProduct(12345678);
+```
+
+### GitHubClient
+
+Integration mit der GitHub API:
+
+```php
+$client = new GitHubClient('github_personal_access_token');
+
+// Repository-Informationen abrufen
+$repo = $client->getRepository('username', 'repo-name');
+```
+
+## Implementierung eines neuen API-Clients
+
+Neue API-Clients können einfach durch Verwendung des `ApiRequestTrait` erstellt werden:
+
+```php
+use App\Framework\Api\ApiRequestTrait;
+
+final class NewApiClient
+{
+    use ApiRequestTrait;
+
+    public function __construct(string $apiKey)
+    {
+        $this->baseUrl = 'https://api.example.com/v1';
+        $this->defaultOptions = new ClientOptions(
+            auth: AuthConfig::bearer($apiKey)
+        );
+        $this->httpClient = new CurlHttpClient();
+    }
+
+    public function getSomeResource(): array
+    {
+        $response = $this->sendRequest(
+            method: HttpMethod::GET,
+            endpoint: 'resources'
+        );
+
+        return $this->decodeJson($response);
+    }
+}
+```
+
+## Fehlerbehandlung
+
+Alle API-Clients werfen eine standardisierte `ApiException` bei Fehlern:
+
+```php
+try {
+    $result = $client->getSomeResource();
+} catch (ApiException $e) {
+    // Zugriff auf Details des Fehlers
+    $statusCode = $e->getCode();
+    $message = $e->getMessage();
+    $responseData = $e->getResponseData();
+}
+```
diff --git a/src/Infrastructure/Api/RapidMail/BlacklistService.php b/src/Infrastructure/Api/RapidMail/BlacklistService.php
new file mode 100644
index 00000000..4673dc5a
--- /dev/null
+++ b/src/Infrastructure/Api/RapidMail/BlacklistService.php
@@ -0,0 +1,39 @@
+<?php
+
+namespace App\Infrastructure\Api\RapidMail;
+
+use App\Framework\Http\Method;
+
+final readonly class BlacklistService
+{
+    public function __construct(
+        private RapidMailApiClient $apiClient
+    ) {}
+
+    /**
+     * Holt die Blacklist
+     */
+    public function getAll(int $page = 1, int $perPage = 50): array
+    {
+        return $this->apiClient->request(Method::GET, 'blacklist', [], [
+            'page' => $page,
+            'per_page' => $perPage
+        ]);
+    }
+
+    /**
+     * Fügt eine E-Mail zur Blacklist hinzu
+     */
+    public function add(string $email): array
+    {
+        return $this->apiClient->request(Method::POST, 'blacklist', ['email' => $email]);
+    }
+
+    /**
+     * Entfernt eine E-Mail von der Blacklist
+     */
+    public function remove(int $blacklistId): void
+    {
+        $this->apiClient->sendRawRequest(Method::DELETE, "blacklist/{$blacklistId}");
+    }
+}
diff --git a/src/Infrastructure/Api/RapidMail/Mailing.php b/src/Infrastructure/Api/RapidMail/Mailing.php
new file mode 100644
index 00000000..66997a64
--- /dev/null
+++ b/src/Infrastructure/Api/RapidMail/Mailing.php
@@ -0,0 +1,35 @@
+<?php
+
+namespace App\Infrastructure\Api\RapidMail;
+
+final readonly class Mailing
+{
+    public function __construct(
+        public ?int $id = null,
+        public ?string $name = null,
+        public ?string $subject = null,
+        public ?string $status = null,
+        public ?string $type = null,
+        public ?int $recipientlistId = null,
+        public ?string $createdAt = null,
+        public ?string $updatedAt = null,
+        public ?string $sentAt = null,
+        public ?array $links = null
+    ) {}
+
+    public static function fromArray(array $data): self
+    {
+        return new self(
+            id: $data['id'] ?? null,
+            name: $data['name'] ?? null,
+            subject: $data['subject'] ?? null,
+            status: $data['status'] ?? null,
+            type: $data['type'] ?? null,
+            recipientlistId: $data['recipientlist_id'] ?? null,
+            createdAt: $data['created'] ?? null,
+            updatedAt: $data['updated'] ?? null,
+            sentAt: $data['sent'] ?? null,
+            links: $data['_links'] ?? null
+        );
+    }
+}
diff --git a/src/Infrastructure/Api/RapidMail/MailingService.php b/src/Infrastructure/Api/RapidMail/MailingService.php
new file mode 100644
index 00000000..5c2d9e3a
--- /dev/null
+++ b/src/Infrastructure/Api/RapidMail/MailingService.php
@@ -0,0 +1,79 @@
+<?php
+
+namespace App\Infrastructure\Api\RapidMail;
+
+use App\Framework\Http\Method;
+
+final readonly class MailingService
+{
+    public function __construct(
+        private RapidMailApiClient $apiClient
+    ) {}
+
+    /**
+     * Holt alle Mailings
+     */
+    public function getAll(array $filter = [], int $page = 1, int $perPage = 50): array
+    {
+        $queryParams = [
+            'page' => $page,
+            'per_page' => $perPage
+        ];
+
+        if (!empty($filter)) {
+            $queryParams['filter'] = $filter;
+        }
+
+        $data = $this->apiClient->request(Method::GET, 'mailings', [], $queryParams);
+
+        $mailings = $data['_embedded']['mailings'] ?? [];
+
+        return array_map(
+                fn(array $item) => Mailing::fromArray($item),
+                $mailings
+        );
+    }
+
+    public function getAllWithPagination(array $filter = [], int $page = 1, int $perPage = 50): array
+    {
+        $queryParams = [
+            'page' => $page,
+            'per_page' => $perPage
+        ];
+
+        if (!empty($filter)) {
+            $queryParams = array_merge($queryParams, $filter);
+        }
+
+        $apiResponse = $this->apiClient->request(Method::GET, 'mailings', [], $queryParams);
+
+        $mailings = $apiResponse['_embedded']['mailings'] ?? [];
+
+        return [
+            'mailings' => array_map(
+                fn(array $item) => Mailing::fromArray($item),
+                $mailings
+            ),
+            'page' => $apiResponse['page'] ?? $page,
+            'page_count' => $apiResponse['page_count'] ?? 1,
+            'total_count' => $apiResponse['total_count'] ?? count($mailings)
+        ];
+    }
+
+    /**
+     * Holt ein spezifisches Mailing
+     */
+    public function get(int $mailingId): Mailing
+    {
+        $data = $this->apiClient->request(Method::GET, "mailings/{$mailingId}");
+        return Mailing::fromArray($data);
+    }
+
+    /**
+     * Sendet ein Mailing
+     */
+    public function send(int $mailingId): array
+    {
+        return $this->apiClient->request(Method::POST, "mailings/{$mailingId}/send");
+    }
+}
diff --git a/src/Infrastructure/Api/RapidMail/RapidMailApiClient.php b/src/Infrastructure/Api/RapidMail/RapidMailApiClient.php
new file mode 100644
index 00000000..e9464637
--- /dev/null
+++ b/src/Infrastructure/Api/RapidMail/RapidMailApiClient.php
@@ -0,0 +1,150 @@
+<?php
+
+namespace App\Infrastructure\Api\RapidMail;
+
+use App\Framework\Api\ApiException;
+use App\Framework\Http\Method;
+use App\Framework\HttpClient\AuthConfig;
+use App\Framework\HttpClient\ClientOptions;
+use App\Framework\HttpClient\ClientRequest;
+use App\Framework\HttpClient\ClientResponse;
+use App\Framework\HttpClient\HttpClient;
+
+final readonly class RapidMailApiClient
+{
+    private ClientOptions $defaultOptions;
+
+    public function __construct(
+        private RapidMailConfig $config,
+        private HttpClient      $httpClient
+    ) {
+        $this->defaultOptions = new ClientOptions(
+            timeout: $this->config->timeout,
+            auth: AuthConfig::basic($this->config->username, $this->config->password)
+        );
+    }
+
+    /**
+     * Sendet eine API-Anfrage und gibt JSON-Daten zurück
+     */
+    public function request(
+        Method $method,
+        string $endpoint,
+        array $data = [],
+        array $queryParams = []
+    ): array {
+        $response = $this->sendRawRequest($method, $endpoint, $data, $queryParams);
+        return $this->handleResponse($response);
+    }
+
+    /**
+     * Sendet eine API-Anfrage und gibt raw Response zurück
+     */
+    public function sendRawRequest(
+        Method $method,
+        string $endpoint,
+        array $data = [],
+        array $queryParams = []
+    ): ClientResponse {
+        $url = $this->config->baseUrl . '/' . ltrim($endpoint, '/');
+
+        $options = $this->defaultOptions;
+        if (!empty($queryParams)) {
+            $options = $options->with(['query' => $queryParams]);
+        }
+
+        if (in_array($method, [Method::GET, Method::DELETE]) && !empty($data)) {
+            $existingQuery = $options->query;
+            $options = $options->with(['query' => array_merge($existingQuery, $data)]);
+            $data = [];
+        }
+
+        $request = empty($data)
+            ? new ClientRequest($method, $url, options: $options)
+            : ClientRequest::json($method, $url, $data, $options);
+
+        $response = $this->httpClient->send($request);
+
+        if (!$response->isSuccessful()) {
+            $this->throwApiException($response);
+        }
+
+        return $response;
+    }
+
+    /**
+     * Standard Query-Parameter
+     */
+    public function getDefaultQueryParams(): array
+    {
+        return [
+            'send_activationmail' => $this->config->sendActivationMail ? 'yes' : 'no',
+            'test_mode' => $this->config->testMode ? 'yes' : 'no'
+        ];
+    }
+
+    /**
+     * Behandelt API-Response
+     */
+    private function handleResponse(ClientResponse $response): array
+    {
+        if (!$response->isJson()) {
+            throw new ApiException('Expected JSON response, got: ' . $response->getContentType(), 0, $response);;
+        }
+
+        try {
+            return $response->json();
+        } catch (\Exception $e) {
+            throw new ApiException('Invalid JSON response: ' . $e->getMessage(), 0, $response);
+        }
+    }
+
+    /**
+     * Wirft API-Exception
+     */
+    private function throwApiException(ClientResponse $response): never
+    {
+        $data = [];
+
+        if ($response->isJson()) {
+            try {
+                $data = $response->json();
+            } catch (\Exception) {
+                // JSON parsing failed
+            }
+        }
+
+        $message = $this->formatErrorMessage($data, $response);
+        throw new ApiException($message, $response->status->value, $response);
+    }
+
+    /**
+     * Formatiert Fehlermeldung
+     */
+    private function formatErrorMessage(array $responseData, ClientResponse $response): string
+    {
+        if (isset($responseData['detail'])) {
+            $message = 'RapidMail API Error: ' . $responseData['detail'];
+
+            if (isset($responseData['validation_messages'])) {
+                $message .= ' - Validation: ' . json_encode(
+                        $responseData['validation_messages'],
+                        JSON_UNESCAPED_UNICODE
+                    );
+            }
+
+            return $message;
+        }
+
+        if (isset($responseData['error'])) {
+            return 'RapidMail API Error: ' . $responseData['error'];
+        }
+
+        if (isset($responseData['message'])) {
+            return 'RapidMail API Error: ' . $responseData['message'];
+        }
+
+        return "RapidMail API Error (HTTP {$response->status->value}): " .
+            substr($response->body, 0, 200);
+    }
+}
diff --git a/src/Infrastructure/Api/RapidMail/RapidMailClient.php b/src/Infrastructure/Api/RapidMail/RapidMailClient.php
new file mode 100644
index 00000000..9ec69f0d
--- /dev/null
+++ b/src/Infrastructure/Api/RapidMail/RapidMailClient.php
@@ -0,0 +1,27 @@
+<?php
+
+namespace App\Infrastructure\Api\RapidMail;
+
+use App\Framework\HttpClient\HttpClient;
+
+final readonly class RapidMailClient
+{
+    public RecipientService $recipients;
+    public RecipientListService $recipientLists;
+    public MailingService $mailings;
+    public StatisticsService $statistics;
+    public BlacklistService $blacklist;
+
+    public function __construct(
+        RapidMailConfig $config,
+        HttpClient $httpClient
+    ) {
+        $apiClient = new RapidMailApiClient($config, $httpClient);
+
+        $this->recipients = new RecipientService($apiClient);
+        $this->recipientLists = new RecipientListService($apiClient);
+        $this->mailings = new MailingService($apiClient);
+        $this->statistics = new StatisticsService($apiClient);
+        $this->blacklist = new BlacklistService($apiClient);
+    }
+}
diff --git a/src/Infrastructure/Api/RapidMail/RapidMailClientInitializer.php b/src/Infrastructure/Api/RapidMail/RapidMailClientInitializer.php
new file mode 100644
index 00000000..b87c5569
--- /dev/null
+++ b/src/Infrastructure/Api/RapidMail/RapidMailClientInitializer.php
@@ -0,0 +1,23 @@
+<?php
+
+namespace App\Infrastructure\Api\RapidMail;
+
+use App\Framework\DI\Initializer;
+use App\Framework\HttpClient\CurlHttpClient;
+
+final readonly class RapidMailClientInitializer
+{
+    #[Initializer]
+    public function __invoke(): RapidMailClient
+    {
+        return new RapidMailClient(
+            new RapidMailConfig(
+                username: '3f60a5c15c3d49c631d0e75b7c1090a3859423a7',
+                password: '572d25dc36e620f14c89e9c75c02c1f3794ba3c0',
+
+                testMode: true,
+            ),
+            new CurlHttpClient()
+        );
+    }
+}
diff --git a/src/Infrastructure/Api/RapidMail/RapidMailConfig.php b/src/Infrastructure/Api/RapidMail/RapidMailConfig.php
new file mode 100644
index 00000000..15668d42
--- /dev/null
+++ b/src/Infrastructure/Api/RapidMail/RapidMailConfig.php
@@ -0,0 +1,15 @@
+<?php
+
+namespace App\Infrastructure\Api\RapidMail;
+
+final readonly class RapidMailConfig
+{
+    public function __construct(
+        public string $username,
+        public string $password,
+        public string $baseUrl = 'https://apiv3.emailsys.net',
+        public bool $testMode = false,
+        public bool $sendActivationMail = true,
+        public float $timeout = 30.0
+    ) {}
+}
diff --git a/src/Infrastructure/Api/RapidMail/RecipientId.php b/src/Infrastructure/Api/RapidMail/RecipientId.php
new file mode 100644
index 00000000..167ee794
--- /dev/null
+++ b/src/Infrastructure/Api/RapidMail/RecipientId.php
@@ -0,0 +1,30 @@
+<?php
+
+namespace App\Infrastructure\Api\RapidMail;
+
+final readonly class RecipientId
+{
+    public function __construct(
+        public int $value,
+    )
+    {
+        if ($value <= 0) {
+            throw new \InvalidArgumentException('RecipientId must be positive');
+        }
+    }
+
+    public static function fromInt(int $id): RecipientId
+    {
+        return new RecipientId($id);
+    }
+
+    public function equals(RecipientId $other): bool
+    {
+        return $this->value === $other->value;
+    }
+
+    public function __toString(): string
+    {
+        return (string) $this->value;
+    }
+}
diff --git a/src/Infrastructure/Api/RapidMail/RecipientListService.php b/src/Infrastructure/Api/RapidMail/RecipientListService.php
new file mode 100644
index 00000000..639758d1
--- /dev/null
+++ b/src/Infrastructure/Api/RapidMail/RecipientListService.php
@@ -0,0 +1,77 @@
+<?php
+
+namespace App\Infrastructure\Api\RapidMail;
+
+use App\Framework\Http\Method;
+use App\Infrastructure\Api\RapidMail\ReadModels\RecipientList;
+
+final readonly class RecipientListService
+{
+    public function __construct(
+        private RapidMailApiClient $apiClient
+    ) {}
+
+    /**
+     * Erstellt eine neue Empfängerliste
+     */
+    public function create(string $name, ?string $description = null): RecipientList
+    {
+        $data = ['name' => $name];
+        if ($description !== null) {
+            $data['description'] = $description;
+        }
+
+        $result = $this->apiClient->request(Method::POST, 'recipientlists', $data);
+        return RecipientList::fromArray($result);
+    }
+
+    /**
+     * Holt alle Empfängerlisten
+     * @return RecipientList[]
+     */
+    public function getAll(int $page = 1, int $perPage = 50): array
+    {
+        $apiResponse = $this->apiClient->request(Method::GET, 'recipientlists', [], [
+            'page' => $page,
+            'per_page' => $perPage
+        ]);
+
+        $recipientlists = $apiResponse['_embedded']['recipientlists'] ?? [];
+
+        return array_map(
+            fn(array $item) => RecipientList::fromArray($item),
+            $recipientlists
+        );
+    }
+
+    /**
+     * Holt eine spezifische Empfängerliste
+     */
+    public function get(RecipientListId $recipientlistId): RecipientList
+    {
+        $data = $this->apiClient->request(Method::GET, "recipientlists/{$recipientlistId->value}");
+        return RecipientList::fromArray($data);
+    }
+
+    /**
+     * Aktualisiert eine Empfängerliste
+     */
+    public function update(RecipientListId $recipientlistId, string $name, ?string $description = null): RecipientList
+    {
+        $data = ['name' => $name];
+        if ($description !== null) {
+            $data['description'] = $description;
+        }
+
+        $result = $this->apiClient->request(Method::PUT, "recipientlists/{$recipientlistId->value}", $data);
+        return RecipientList::fromArray($result);
+    }
+
+    /**
+     * Löscht eine Empfängerliste
+     */
+    public function delete(RecipientListId $recipientlistId): void
+    {
+        $this->apiClient->sendRawRequest(Method::DELETE, "recipientlists/{$recipientlistId->value}");
+    }
+}
diff --git a/src/Infrastructure/Api/RapidMail/RecipientService.php b/src/Infrastructure/Api/RapidMail/RecipientService.php
new file mode 100644
index 00000000..5f8d9653
--- /dev/null
+++ b/src/Infrastructure/Api/RapidMail/RecipientService.php
@@ -0,0 +1,114 @@
+<?php
+
+namespace App\Infrastructure\Api\RapidMail;
+
+use App\Framework\Http\Method;
+use App\Infrastructure\Api\RapidMail\Commands\CreateRecipientCommand;
+use App\Infrastructure\Api\RapidMail\Commands\UpdateRecipientCommand;
+use App\Infrastructure\Api\RapidMail\ReadModels\Recipient;
+
+/**
+ * Modern RecipientService with Value Objects and Command/Query separation
+ *
+ * Use the new methods (createWithCommand, get with RecipientId, etc.) for type safety.
+ * Legacy methods are marked as deprecated but still functional for backward compatibility.
+ */
+final readonly class RecipientService
+{
+    public function __construct(
+        private RapidMailApiClient $apiClient
+    ) {}
+
+    /**
+     * Creates a new recipient using Command pattern (RECOMMENDED)
+     */
+    public function createWithCommand(CreateRecipientCommand $command): Recipient
+    {
+        $data = $this->apiClient->request(
+            Method::POST,
+            'recipients',
+            $command->toArray(),
+            $this->apiClient->getDefaultQueryParams()
+        );
+
+        return Recipient::fromArray($data);
+    }
+
+    /**
+     * Gets a recipient by ID using Value Object (RECOMMENDED)
+     */
+    public function get(RecipientId $recipientId): Recipient
+    {
+        $data = $this->apiClient->request(Method::GET, "recipients/{$recipientId->value}");
+        return Recipient::fromArray($data);
+    }
+
+    /**
+     * Updates a recipient using Command pattern (RECOMMENDED)
+     */
+    public function updateWithCommand(UpdateRecipientCommand $command): Recipient
+    {
+        $data = $this->apiClient->request(
+            Method::PATCH,
+            "recipients/{$command->id->value}",
+            $command->toArray()
+        );
+
+        return Recipient::fromArray($data);
+    }
+
+    /**
+     * Deletes a recipient using Value Object (RECOMMENDED)
+     */
+    public function delete(RecipientId $recipientId): void
+    {
+        $this->apiClient->sendRawRequest(Method::DELETE, "recipients/{$recipientId->value}");
+    }
+
+    /**
+     * Searches for recipients with filters (RECOMMENDED)
+     * @return Recipient[]
+     */
+    public function search(array $filter = [], int $page = 1, int $perPage = 50): array
+    {
+        $queryParams = [
+            'page' => $page,
+            'per_page' => $perPage
+        ];
+
+        if (!empty($filter)) {
+            $queryParams = array_merge($queryParams, $filter);
+        }
+
+        $apiResponse = $this->apiClient->request(Method::GET, 'recipients', [], $queryParams);
+
+        $recipients = $apiResponse['_embedded']['recipients'] ?? [];
+
+        return array_map(
+            fn(array $item) => Recipient::fromArray($item),
+            $recipients
+        );
+    }
+
+    /**
+     * Finds a specific recipient by email (RECOMMENDED)
+     */
+    public function findByEmail(string $email, ?RecipientListId $recipientListId = null): ?Recipient
+    {
+        $filter = ['email' => $email];
+        if ($recipientListId !== null) {
+            $filter['recipientlist_id'] = $recipientListId->value;
+        }
+
+        $recipients = $this->search($filter, 1, 1);
+        return empty($recipients) ? null : $recipients[0];
+    }
+
+    /**
+     * Checks if a recipient exists (RECOMMENDED)
+     */
+    public function exists(string $email, ?RecipientListId $recipientListId = null): bool
+    {
+        return $this->findByEmail($email, $recipientListId) !== null;
+    }
+}
diff --git a/src/Infrastructure/Api/RapidMail/StatisticsService.php b/src/Infrastructure/Api/RapidMail/StatisticsService.php
new file mode 100644
index 00000000..b5d92008
--- /dev/null
+++ b/src/Infrastructure/Api/RapidMail/StatisticsService.php
@@ -0,0 +1,41 @@
+<?php
+
+namespace App\Infrastructure\Api\RapidMail;
+
+use App\Framework\Http\Method;
+
+final readonly class StatisticsService
+{
+    public function __construct(
+        private RapidMailApiClient $apiClient
+    ) {}
+
+    /**
+     * Holt Statistiken für ein Mailing
+     */
+    public function getMailingStats(int $mailingId): array
+    {
+        return $this->apiClient->request(
+            Method::GET,
+            "mailings/{$mailingId}/stats",
+            [],
+            $this->apiClient->getDefaultQueryParams()
+        );
+    }
+
+    /**
+     * Holt Klick-Statistiken für ein Mailing
+     */
+    public function getClickStats(int $mailingId): array
+    {
+        return $this->apiClient->request(Method::GET, "mailings/{$mailingId}/stats/clicks");
+    }
+
+    /**
+     * Holt Öffnungs-Statistiken für ein Mailing
+     */
+    public function getOpenStats(int $mailingId): array
+    {
+        return $this->apiClient->request(Method::GET, "mailings/{$mailingId}/stats/opens");
+    }
+}
diff --git a/src/Infrastructure/Api/RapidMailClient.php b/src/Infrastructure/Api/RapidMailClient.php
new file mode 100644
index 00000000..06590160
--- /dev/null
+++ b/src/Infrastructure/Api/RapidMailClient.php
@@ -0,0 +1,96 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Infrastructure\Api;
+
+use App\Framework\Api\ApiException;
+use App\Framework\Api\ApiRequestTrait;
+use App\Framework\Http\Method;
+use App\Framework\HttpClient\AuthConfig;
+use App\Framework\HttpClient\ClientOptions;
+use App\Framework\HttpClient\CurlHttpClient;
+use App\Framework\HttpClient\HttpClient;
+
+final class RapidMailClient
+{
+    use ApiRequestTrait;
+
+    public function __construct(
+        string $username,
+        string $password,
+        ?HttpClient $httpClient = null
+    ) {
+        $this->baseUrl = 'https://apiv3.emailsys.net/v1';
+        $this->defaultOptions = new ClientOptions(
+            auth: AuthConfig::basic($username, $password)
+        );
+        $this->httpClient = $httpClient ?? new CurlHttpClient();
+    }
+
+    /**
+     * Fügt einen Empfänger zu einer Mailingliste hinzu
+     */
+    public function addRecipient(string $name, string $email, int $recipientlistId): array
+    {
+        $response = $this->sendRequest(
+            method: Method::POST,
+            endpoint: 'recipients',
+            data: [
+                'firstname' => $name,
+                'email' => $email,
+                'recipientlist_id' => $recipientlistId,
+            ],
+            options: $this->defaultOptions->with([
+                'query' => [
+                    'send_activationmail' => 'yes',
+                    'test_mode' => 'yes'
+                ]
+            ])
+        );
+
+        return $this->decodeJson($response);
+    }
+
+    /**
+     * Löscht einen Empfänger aus einer Mailingliste
+     */
+    public function deleteRecipient(int $recipientId): void
+    {
+        $this->sendRequest(
+            method: Method::DELETE,
+            endpoint: "recipients/{$recipientId}"
+        );
+    }
+
+    /**
+     * Ruft die Mailinglisten ab
+     */
+    public function getRecipientLists(): array
+    {
+        $response = $this->sendRequest(
+            method: Method::GET,
+            endpoint: 'recipientlists'
+        );
+
+        return $this->decodeJson($response);
+    }
+
+    /**
+     * Sucht nach Empfängern in einer Mailingliste
+     */
+    public function searchRecipients(string $email, int $recipientlistId): array
+    {
+        $response = $this->sendRequest(
+            method: Method::GET,
+            endpoint: 'recipients',
+            data: [
+                'filter' => [
+                    'email' => $email,
+                    'recipientlist_id' => $recipientlistId
+                ]
+            ]
+        );
+
+        return $this->decodeJson($response);
+    }
+}
diff --git a/src/Infrastructure/Api/ShopifyClient.php b/src/Infrastructure/Api/ShopifyClient.php
new file mode 100644
index 00000000..f7113e49
--- /dev/null
+++ b/src/Infrastructure/Api/ShopifyClient.php
@@ -0,0 +1,378 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Infrastructure\Api;
+
+use App\Framework\Api\ApiException;
+use App\Framework\Api\ApiRequestTrait;
+use App\Framework\Http\Method;
+use App\Framework\HttpClient\AuthConfig;
+use App\Framework\HttpClient\ClientOptions;
+use App\Framework\HttpClient\ClientResponse;
+use App\Framework\HttpClient\CurlHttpClient;
+use App\Framework\HttpClient\HttpClient;
+
+final class ShopifyClient
+{
+    use ApiRequestTrait;
+
+    private string $apiVersion;
+
+    /**
+     * Erstellt einen neuen Shopify API-Client
+     *
+     * @param string $shopDomain Die Shopify-Domain (z.B. 'my-store.myshopify.com')
+     * @param string $accessToken Das Zugriffstoken für die API
+     * @param string $apiVersion Die API-Version (z.B. '2023-10')
+     * @param HttpClient|null $httpClient Ein optionaler HTTP-Client
+     */
+    public function __construct(
+        string $shopDomain,
+        string $accessToken,
+        string $apiVersion = '2024-04',
+        ?HttpClient $httpClient = null
+    ) {
+        $this->baseUrl = "https://{$shopDomain}/admin/api/{$apiVersion}";
+        $this->apiVersion = $apiVersion;
+
+        $this->defaultOptions = new ClientOptions(
+            auth: AuthConfig::custom([
+                'headers' => ['X-Shopify-Access-Token' => $accessToken]
+            ])
+        );
+
+        $this->httpClient = $httpClient ?? new CurlHttpClient();
+    }
+
+    /**
+     * Ruft eine Liste aller Produkte ab
+     *
+     * @param array $options Optionale Parameter (limit, since_id, usw.)
+     * @return array Die Produktliste
+     */
+    public function getProducts(array $options = []): array
+    {
+        $queryParams = $this->buildQueryParams($options);
+        $endpoint = 'products.json' . $queryParams;
+
+        $response = $this->sendRequest(
+            method: Method::GET,
+            endpoint: $endpoint
+        );
+
+        return $this->decodeJson($response)['products'] ?? [];
+    }
+
+    /**
+     * Ruft ein einzelnes Produkt ab
+     *
+     * @param int $productId Die Produkt-ID
+     * @return array Die Produktdaten
+     */
+    public function getProduct(int $productId): array
+    {
+        $response = $this->sendRequest(
+            method: Method::GET,
+            endpoint: "products/{$productId}.json"
+        );
+
+        return $this->decodeJson($response)['product'] ?? [];
+    }
+
+    /**
+     * Erstellt ein neues Produkt
+     *
+     * @param array $productData Die Produktdaten
+     * @return array Das erstellte Produkt
+     */
+    public function createProduct(array $productData): array
+    {
+        $response = $this->sendRequest(
+            method: Method::POST,
+            endpoint: 'products.json',
+            data: ['product' => $productData]
+        );
+
+        return $this->decodeJson($response)['product'] ?? [];
+    }
+
+    /**
+     * Aktualisiert ein bestehendes Produkt
+     *
+     * @param int $productId Die Produkt-ID
+     * @param array $productData Die zu aktualisierenden Produktdaten
+     * @return array Das aktualisierte Produkt
+     */
+    public function updateProduct(int $productId, array $productData): array
+    {
+        $response = $this->sendRequest(
+            method: Method::PUT,
+            endpoint: "products/{$productId}.json",
+            data: ['product' => $productData]
+        );
+
+        return $this->decodeJson($response)['product'] ?? [];
+    }
+
+    /**
+     * Löscht ein Produkt
+     *
+     * @param int $productId Die Produkt-ID
+     * @return bool Erfolg oder Misserfolg
+     */
+    public function deleteProduct(int $productId): bool
+    {
+        $response = $this->sendRequest(
+            method: Method::DELETE,
+            endpoint: "products/{$productId}.json"
+        );
+
+        return $response->status->value === 200;
+    }
+
+    /**
+     * Ruft eine Liste aller Bestellungen ab
+     *
+     * @param array $options Optionale Parameter (limit, status, usw.)
+     * @return array Die Bestellungsliste
+     */
+    public function getOrders(array $options = []): array
+    {
+        $queryParams = $this->buildQueryParams($options);
+        $endpoint = 'orders.json' . $queryParams;
+
+        $response = $this->sendRequest(
+            method: Method::GET,
+            endpoint: $endpoint
+        );
+
+        return $this->decodeJson($response)['orders'] ?? [];
+    }
+
+    /**
+     * Ruft eine einzelne Bestellung ab
+     *
+     * @param int $orderId Die Bestellungs-ID
+     * @return array Die Bestellungsdaten
+     */
+    public function getOrder(int $orderId): array
+    {
+        $response = $this->sendRequest(
+            method: Method::GET,
+            endpoint: "orders/{$orderId}.json"
+        );
+
+        return $this->decodeJson($response)['order'] ?? [];
+    }
+
+    /**
+     * Erstellt eine neue Bestellung
+     *
+     * @param array $orderData Die Bestellungsdaten
+     * @return array Die erstellte Bestellung
+     */
+    public function createOrder(array $orderData): array
+    {
+        $response = $this->sendRequest(
+            method: Method::POST,
+            endpoint: 'orders.json',
+            data: ['order' => $orderData]
+        );
+
+        return $this->decodeJson($response)['order'] ?? [];
+    }
+
+    /**
+     * Ruft Informationen über den Shop ab
+     *
+     * @return array Die Shop-Informationen
+     */
+    public function getShopInfo(): array
+    {
+        $response = $this->sendRequest(
+            method: Method::GET,
+            endpoint: 'shop.json'
+        );
+
+        return $this->decodeJson($response)['shop'] ?? [];
+    }
+
+    /**
+     * Ruft eine Liste aller Kunden ab
+     *
+     * @param array $options Optionale Parameter (limit, since_id, usw.)
+     * @return array Die Kundenliste
+     */
+    public function getCustomers(array $options = []): array
+    {
+        $queryParams = $this->buildQueryParams($options);
+        $endpoint = 'customers.json' . $queryParams;
+
+        $response = $this->sendRequest(
+            method: Method::GET,
+            endpoint: $endpoint
+        );
+
+        return $this->decodeJson($response)['customers'] ?? [];
+    }
+
+    /**
+     * Erstellt einen neuen Kunden
+     *
+     * @param array $customerData Die Kundendaten
+     * @return array Der erstellte Kunde
+     */
+    public function createCustomer(array $customerData): array
+    {
+        $response = $this->sendRequest(
+            method: Method::POST,
+            endpoint: 'customers.json',
+            data: ['customer' => $customerData]
+        );
+
+        return $this->decodeJson($response)['customer'] ?? [];
+    }
+
+    /**
+     * Ruft einen einzelnen Kunden ab
+     *
+     * @param int $customerId Die Kunden-ID
+     * @return array Die Kundendaten
+     */
+    public function getCustomer(int $customerId): array
+    {
+        $response = $this->sendRequest(
+            method: Method::GET,
+            endpoint: "customers/{$customerId}.json"
+        );
+
+        return $this->decodeJson($response)['customer'] ?? [];
+    }
+
+    /**
+     * Erstellt einen neuen Webhook
+     *
+     * @param string $topic Das Webhook-Thema (z.B. 'orders/create')
+     * @param string $address Die URL, die aufgerufen werden soll
+     * @param string $format Das Format (JSON oder XML)
+     * @return array Die Webhook-Daten
+     */
+    public function createWebhook(string $topic, string $address, string $format = 'json'): array
+    {
+        $response = $this->sendRequest(
+            method: Method::POST,
+            endpoint: 'webhooks.json',
+            data: [
+                'webhook' => [
+                    'topic' => $topic,
+                    'address' => $address,
+                    'format' => $format
+                ]
+            ]
+        );
+
+        return $this->decodeJson($response)['webhook'] ?? [];
+    }
+
+    /**
+     * Ruft alle Webhooks ab
+     *
+     * @return array Die Liste der Webhooks
+     */
+    public function getWebhooks(): array
+    {
+        $response = $this->sendRequest(
+            method: Method::GET,
+            endpoint: 'webhooks.json'
+        );
+
+        return $this->decodeJson($response)['webhooks'] ?? [];
+    }
+
+    /**
+     * Sucht Produkte anhand von Suchkriterien
+     *
+     * @param string $query Die Suchanfrage
+     * @param array $options Zusätzliche Optionen
+     * @return array Die gefundenen Produkte
+     */
+    public function searchProducts(string $query, array $options = []): array
+    {
+        $options = array_merge($options, ['query' => $query]);
+        $queryParams = $this->buildQueryParams($options);
+
+        $response = $this->sendRequest(
+            method: Method::GET,
+            endpoint: 'products/search.json' . $queryParams
+        );
+
+        return $this->decodeJson($response)['products'] ?? [];
+    }
+
+    /**
+     * Ruft Metafields für eine Ressource ab
+     *
+     * @param string $resourceType Der Ressourcentyp (product, customer, usw.)
+     * @param int $resourceId Die Ressourcen-ID
+     * @return array Die Metafields
+     */
+    public function getMetafields(string $resourceType, int $resourceId): array
+    {
+        $response = $this->sendRequest(
+            method: Method::GET,
+            endpoint: "{$resourceType}s/{$resourceId}/metafields.json"
+        );
+
+        return $this->decodeJson($response)['metafields'] ?? [];
+    }
+
+    /**
+     * Verarbeitet Rate-Limiting-Informationen aus den Headern
+     *
+     * @param ClientResponse $response Die API-Antwort
+     * @return array Rate-Limiting-Informationen
+     */
+    public function getRateLimitInfo(ClientResponse $response): array
+    {
+        $headers = $response->headers->all();
+
+        return [
+            'limit' => (int)($headers['X-Shopify-Shop-Api-Call-Limit'][0] ?? 0),
+            'remaining' => isset($headers['X-Shopify-Shop-Api-Call-Limit'][0])
+                ? $this->parseRemainingCalls($headers['X-Shopify-Shop-Api-Call-Limit'][0])
+                : null,
+        ];
+    }
+
+    /**
+     * Baut Query-Parameter aus einem Options-Array
+     *
+     * @param array $options Die Optionen
+     * @return string Die Query-Parameter als String
+     */
+    private function buildQueryParams(array $options): string
+    {
+        if (empty($options)) {
+            return '';
+        }
+
+        return '?' . http_build_query($options);
+    }
+
+    /**
+     * Parst die verbleibenden API-Aufrufe aus dem Header
+     *
+     * @param string $limitHeader Der Header-Wert
+     * @return int|null Die verbleibenden Aufrufe
+     */
+    private function parseRemainingCalls(string $limitHeader): ?int
+    {
+        if (preg_match('/^(\d+)\/(\d+)$/', $limitHeader, $matches)) {
+            $current = (int)$matches[1];
+            $limit = (int)$matches[2];
+            return $limit - $current;
+        }
+
+        return null;
+    }
+}
diff --git a/src/Infrastructure/GeoIp/Country.php b/src/Infrastructure/GeoIp/Country.php
new file mode 100644
index 00000000..6abab067
--- /dev/null
+++ b/src/Infrastructure/GeoIp/Country.php
@@ -0,0 +1,27 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Infrastructure\GeoIp;
+
+final readonly class Country
+{
+    public function __construct(
+        public string $code,
+        public string $nameEn,
+        public string $nameDe,
+        public string $nameNative,
+        public string $updatedAt
+    ) {
+    }
+
+    public function toArray(): array
+    {
+        return [
+            'code' => $this->code,
+            'name_en' => $this->nameEn,
+            'name_de' => $this->nameDe,
+            'name_native' => $this->nameNative,
+            'updated_at' => $this->updatedAt
+        ];
+    }
+}
diff --git a/src/Infrastructure/GeoIp/CountryDataService.php b/src/Infrastructure/GeoIp/CountryDataService.php
new file mode 100644
index 00000000..1e1f2602
--- /dev/null
+++ b/src/Infrastructure/GeoIp/CountryDataService.php
@@ -0,0 +1,100 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Infrastructure\GeoIp;
+
+use PDO;
+use RuntimeException;
+
+final class CountryDataService
+{
+    private const string RESTCOUNTRIES_API_URL = 'https://restcountries.com/v3.1/all?fields=cca2,name,translations';
+
+    public function __construct(
+        private readonly PDO $database
+    ) {
+    }
+
+    public function loadCountryData(): int
+    {
+        echo "Lade Länderdaten von RestCountries API...\n";
+
+        $jsonData = file_get_contents(self::RESTCOUNTRIES_API_URL);
+        if (!$jsonData) {
+            throw new RuntimeException('Konnte Länderdaten nicht herunterladen');
+        }
+
+        $countries = json_decode($jsonData, true);
+        if (!$countries) {
+            throw new RuntimeException('Ungültige JSON-Daten erhalten');
+        }
+
+        $this->database->beginTransaction();
+        $this->database->exec('DELETE FROM countries');
+
+        $stmt = $this->database->prepare('INSERT INTO countries (code, name_en, name_de, name_native, updated_at) VALUES (?, ?, ?, ?, ?)');
+
+        $processed = 0;
+        foreach ($countries as $countryData) {
+            $country = $this->parseCountryData($countryData);
+            if ($country) {
+                $stmt->execute([
+                    $country->code,
+                    $country->nameEn,
+                    $country->nameDe,
+                    $country->nameNative,
+                    $country->updatedAt
+                ]);
+                $processed++;
+            }
+        }
+
+        $this->database->commit();
+        echo "Länderdatenbank aktualisiert: {$processed} Länder geladen\n";
+
+        return $processed;
+    }
+
+    public function getCountryByCode(string $code): ?Country
+    {
+        $stmt = $this->database->prepare('SELECT * FROM countries WHERE code = ?');
+        $stmt->execute([$code]);
+        $result = $stmt->fetch(PDO::FETCH_ASSOC);
+
+        if (!$result) {
+            return null;
+        }
+
+        return new Country(
+            code: $result['code'],
+            nameEn: $result['name_en'],
+            nameDe: $result['name_de'],
+            nameNative: $result['name_native'],
+            updatedAt: $result['updated_at']
+        );
+    }
+
+    private function parseCountryData(array $countryData): ?Country
+    {
+        $code = $countryData['cca2'] ?? null;
+        $nameEn = $countryData['name']['common'] ?? null;
+
+        if (!$code || !$nameEn) {
+            return null;
+        }
+
+        $nameDe = $countryData['translations']['deu']['common'] ?? $nameEn;
+        $nativeNames = $countryData['name']['nativeName'] ?? [];
+        $nameNative = !empty($nativeNames)
+            ? $nativeNames[array_key_first($nativeNames)]['common'] ?? $nameEn
+            : $nameEn;
+
+        return new Country(
+            code: $code,
+            nameEn: $nameEn,
+            nameDe: $nameDe,
+            nameNative: $nameNative,
+            updatedAt: date('Y-m-d H:i:s')
+        );
+    }
+}
diff --git a/src/Infrastructure/GeoIp/CountryInfo.php b/src/Infrastructure/GeoIp/CountryInfo.php
new file mode 100644
index 00000000..68ca43d3
--- /dev/null
+++ b/src/Infrastructure/GeoIp/CountryInfo.php
@@ -0,0 +1,34 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Infrastructure\GeoIp;
+
+final readonly class CountryInfo
+{
+    public function __construct(
+        public string $ip,
+        public ?string $countryCode,
+        public ?Country $country = null
+    ) {
+    }
+
+    public function hasCountry(): bool
+    {
+        return $this->countryCode !== null;
+    }
+
+    public function getGermanName(): ?string
+    {
+        return $this->country?->nameDe ?? $this->countryCode;
+    }
+
+    public function getEnglishName(): ?string
+    {
+        return $this->country?->nameEn ?? $this->countryCode;
+    }
+
+    public function getNativeName(): ?string
+    {
+        return $this->country?->nameNative ?? $this->countryCode;
+    }
+}
diff --git a/src/Infrastructure/GeoIp/DatabaseSetup.php b/src/Infrastructure/GeoIp/DatabaseSetup.php
new file mode 100644
index 00000000..2b86376a
--- /dev/null
+++ b/src/Infrastructure/GeoIp/DatabaseSetup.php
@@ -0,0 +1,80 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Infrastructure\GeoIp;
+
+use PDO;
+
+final readonly class DatabaseSetup
+{
+    private PDO $database;
+
+    public function __construct(string $databasePath)
+    {
+        $this->database = $this->initializeDatabase($databasePath);
+    }
+
+    public function setupCompleteDatabase(): void
+    {
+        echo "=== GeoIP-Datenbank Setup ===\n";
+
+        // 1. Länderdaten laden
+        echo "Schritt 1: Lade Länderdaten...\n";
+        $countryService = new CountryDataService($this->database);
+        $countryService->loadCountryData();
+
+        // 2. IP-Ranges laden
+        echo "Schritt 2: Lade IP-Ranges...\n";
+        $ipRangeService = new IpRangeService($this->database);
+        $ipRangeService->loadIpRanges();
+
+        echo "Setup abgeschlossen!\n";
+    }
+
+    public function setupCountryDataOnly(): void
+    {
+        echo "=== Länderdaten Setup ===\n";
+        $countryService = new CountryDataService($this->database);
+        $countryService->loadCountryData();
+        echo "Länderdaten Setup abgeschlossen!\n";
+    }
+
+    public function setupIpRangesOnly(): void
+    {
+        echo "=== IP-Ranges Setup ===\n";
+        $ipRangeService = new IpRangeService($this->database);
+        $ipRangeService->loadIpRanges();
+        echo "IP-Ranges Setup abgeschlossen!\n";
+    }
+
+    private function initializeDatabase(string $file): PDO
+    {
+        $directory = dirname($file);
+        if (!is_dir($directory)) {
+            mkdir($directory, 0755, true);
+        }
+
+        $db = new PDO('sqlite:' . $file);
+        $db->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
+
+        // IP-Ranges Tabelle
+        $db->exec('CREATE TABLE IF NOT EXISTS ip_ranges (
+            id INTEGER PRIMARY KEY,
+            ip_start INTEGER,
+            ip_end INTEGER,
+            country TEXT
+        )');
+        $db->exec('CREATE INDEX IF NOT EXISTS idx_ip_range ON ip_ranges (ip_start, ip_end)');
+
+        // Länder-Tabelle für ISO-Daten
+        $db->exec('CREATE TABLE IF NOT EXISTS countries (
+            code TEXT PRIMARY KEY,
+            name_en TEXT,
+            name_de TEXT,
+            name_native TEXT,
+            updated_at TEXT
+        )');
+
+        return $db;
+    }
+}
diff --git a/src/Infrastructure/GeoIp/GeoIp.php b/src/Infrastructure/GeoIp/GeoIp.php
new file mode 100644
index 00000000..5e2db20a
--- /dev/null
+++ b/src/Infrastructure/GeoIp/GeoIp.php
@@ -0,0 +1,113 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Infrastructure\GeoIp;
+
+use App\Framework\Http\IpAddress;
+use PDO;
+
+final class GeoIp
+{
+    private readonly PDO $database;
+    private readonly IpRangeService $ipRangeService;
+    private readonly CountryDataService $countryDataService;
+
+    public function __construct(?string $databasePath = null)
+    {
+        $databasePath = $databasePath ?? __DIR__ . '/data/ip_country.sqlite';
+        $this->database = $this->initializeDatabase($databasePath);
+        $this->ipRangeService = new IpRangeService($this->database);
+        $this->countryDataService = new CountryDataService($this->database);
+    }
+
+    /**
+     * @deprecated Use DatabaseSetup::setupCompleteDatabase() instead
+     */
+    public function loadDatabase(): void
+    {
+        $setup = new DatabaseSetup(__DIR__ . '/data/ip_country.sqlite');
+        $setup->setupIpRangesOnly();
+    }
+
+    public function getCountryForString(string $ip): ?string
+    {
+        return $this->ipRangeService->getCountryCodeForIp($ip);
+    }
+
+    public function getCountryForIp(IpAddress $ipAddress): ?string
+    {
+        if ($ipAddress->isPrivate()) {
+            return null;
+        }
+
+        return $this->getCountryForString($ipAddress->value);
+    }
+
+    public function getCountryInfo(string $ip): CountryInfo
+    {
+        $countryCode = $this->getCountryForString($ip);
+
+        if (!$countryCode) {
+            return new CountryInfo($ip, null);
+        }
+
+        $country = $this->countryDataService->getCountryByCode($countryCode);
+
+        return new CountryInfo($ip, $countryCode, $country);
+    }
+
+    public function getCountryInfoForIp(IpAddress $ipAddress): CountryInfo
+    {
+        if ($ipAddress->isPrivate()) {
+            return new CountryInfo($ipAddress->value, null);
+        }
+
+        return $this->getCountryInfo($ipAddress->value);
+    }
+
+    public function getCountryNameGerman(string $ip): ?string
+    {
+        return $this->getCountryInfo($ip)->getGermanName();
+    }
+
+    public function getCountryNameEnglish(string $ip): ?string
+    {
+        return $this->getCountryInfo($ip)->getEnglishName();
+    }
+
+    public function getCountryNameNative(string $ip): ?string
+    {
+        return $this->getCountryInfo($ip)->getNativeName();
+    }
+
+    private function initializeDatabase(string $file): PDO
+    {
+        $directory = dirname($file);
+        if (!is_dir($directory)) {
+            mkdir($directory, 0755, true);
+        }
+
+        $db = new PDO('sqlite:' . $file);
+        $db->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
+
+        // IP-Ranges Tabelle
+        $db->exec('CREATE TABLE IF NOT EXISTS ip_ranges (
+            id INTEGER PRIMARY KEY,
+            ip_start INTEGER,
+            ip_end INTEGER,
+            country TEXT
+        )');
+        $db->exec('CREATE INDEX IF NOT EXISTS idx_ip_range ON ip_ranges (ip_start, ip_end)');
+
+        // Länder-Tabelle für ISO-Daten
+        $db->exec('CREATE TABLE IF NOT EXISTS countries (
+            code TEXT PRIMARY KEY,
+            name_en TEXT,
+            name_de TEXT,
+            name_native TEXT,
+            updated_at TEXT
+        )');
+
+        return $db;
+    }
+}
diff --git a/src/Infrastructure/GeoIp/IpRangeService.php b/src/Infrastructure/GeoIp/IpRangeService.php
new file mode 100644
index 00000000..111ab10d
--- /dev/null
+++ b/src/Infrastructure/GeoIp/IpRangeService.php
@@ -0,0 +1,129 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Infrastructure\GeoIp;
+
+use PDO;
+use Generator;
+use RuntimeException;
+
+final class IpRangeService
+{
+    private const array RIR_SOURCES = [
+        'RIPE' => 'https://ftp.ripe.net/pub/stats/ripencc/delegated-ripencc-latest',      // Europa, Westasien, Teile Afrikas
+        'ARIN' => 'https://ftp.arin.net/pub/stats/arin/delegated-arin-extended-latest',   // Nordamerika
+        'APNIC' => 'https://ftp.apnic.net/pub/stats/apnic/delegated-apnic-latest',        // Asien-Pazifik
+        'LACNIC' => 'https://ftp.lacnic.net/pub/stats/lacnic/delegated-lacnic-latest',    // Lateinamerika
+        'AFRINIC' => 'https://ftp.afrinic.net/pub/stats/afrinic/delegated-afrinic-latest' // Afrika
+    ];
+
+    private const int BATCH_SIZE = 1000;
+
+    public function __construct(
+        private readonly PDO $database
+    ) {
+    }
+
+    public function loadIpRanges(): int
+    {
+        $this->database->exec('DELETE FROM ip_ranges');
+
+        $this->database->beginTransaction();
+        $stmt = $this->database->prepare('INSERT INTO ip_ranges (ip_start, ip_end, country) VALUES (?, ?, ?)');
+
+        $totalProcessed = 0;
+
+        foreach (self::RIR_SOURCES as $rir => $url) {
+            echo "Verarbeite {$rir}-Datenbank...\n";
+
+            try {
+                $processed = 0;
+                foreach ($this->parseIpRanges($url) as $ipRange) {
+                    $stmt->execute([$ipRange['ip_start'], $ipRange['ip_end'], $ipRange['country']]);
+                    $processed++;
+                    $totalProcessed++;
+
+                    if ($totalProcessed % self::BATCH_SIZE === 0) {
+                        $this->database->commit();
+                        $this->database->beginTransaction();
+                        echo "Verarbeitet: {$totalProcessed} Einträge insgesamt\n";
+                    }
+                }
+                echo "{$rir}: {$processed} Einträge hinzugefügt\n";
+
+            } catch (\Exception $e) {
+                echo "Fehler bei {$rir}: " . $e->getMessage() . "\n";
+                // Weiter mit nächster Datenbank
+            }
+        }
+
+        $this->database->commit();
+        echo "Datenbank-Aufbau abgeschlossen. Insgesamt {$totalProcessed} Einträge aus allen RIRs.\n";
+
+        return $totalProcessed;
+    }
+
+    public function getCountryCodeForIp(string $ip): ?string
+    {
+        $ipLong = ip2long($ip);
+        if ($ipLong === false) {
+            return null;
+        }
+
+        $stmt = $this->database->prepare('SELECT country FROM ip_ranges WHERE ip_start <= ? AND ip_end >= ?');
+        $stmt->execute([$ipLong, $ipLong]);
+        $result = $stmt->fetch(PDO::FETCH_ASSOC);
+
+        return $result ? $result['country'] : null;
+    }
+
+    /**
+     * Generator für speicherschonende Verarbeitung der IP-Ranges
+     */
+    private function parseIpRanges(string $url): Generator
+    {
+        $context = stream_context_create([
+            'http' => [
+                'timeout' => 300 // 5 Minuten Timeout
+            ]
+        ]);
+
+        $handle = fopen($url, 'r', false, $context);
+        if (!$handle) {
+            throw new RuntimeException("Konnte URL nicht öffnen: {$url}");
+        }
+
+        try {
+            while (($line = fgets($handle)) !== false) {
+                $line = trim($line);
+
+                if (str_contains($line, '|ipv4|')) {
+                    $parts = explode('|', $line);
+
+                    if (count($parts) < 5) {
+                        continue;
+                    }
+
+                    $country = $parts[1];
+                    $ip = $parts[3];
+                    $count = (int)$parts[4];
+
+                    $ipStart = ip2long($ip);
+                    if ($ipStart === false) {
+                        continue;
+                    }
+
+                    $ipEnd = $ipStart + $count - 1;
+
+                    yield [
+                        'ip_start' => $ipStart,
+                        'ip_end' => $ipEnd,
+                        'country' => $country
+                    ];
+                }
+            }
+        } finally {
+            fclose($handle);
+        }
+    }
+}
diff --git a/tests/Domain/QrCode/End2EndTest.php b/tests/Domain/QrCode/End2EndTest.php
new file mode 100644
index 00000000..892d9847
--- /dev/null
+++ b/tests/Domain/QrCode/End2EndTest.php
@@ -0,0 +1,84 @@
+<?php
+
+declare(strict_types=1);
+
+use App\Application\Service\QrCodeService;
+use App\Domain\QrCode\QrCode;
+use App\Domain\QrCode\Service\QrCodeEncoder;
+use App\Domain\QrCode\Service\QrCodeGenerator;
+use App\Domain\QrCode\Service\QrCodeMasker;
+use App\Domain\QrCode\Service\QrCodeRenderer;
+use App\Domain\QrCode\Service\ReedSolomon;
+use App\Domain\QrCode\ValueObject\ErrorCorrectionLevel;
+use App\Domain\QrCode\ValueObject\QrCodeMatrix;
+use App\Domain\QrCode\ValueObject\QrCodeVersion;
+
+test('End-to-End QR-Code-Generierung funktioniert', function () {
+    // Abhängigkeiten aufbauen
+    $encoder = new QrCodeEncoder();
+    $renderer = new QrCodeRenderer(new QrCodeMasker(), new ReedSolomon());
+    $generator = new QrCodeGenerator($encoder, $renderer);
+
+    // Test-Daten
+    $data = 'https://example.com';
+    $errorLevel = ErrorCorrectionLevel::M;
+    $version = 2; // Fixe Version für Test-Vorhersagbarkeit
+
+    // QR-Code generieren
+    $qrCode = new QrCode($data, $errorLevel, new QrCodeVersion($version));
+    $matrix = $generator->generate($qrCode);
+
+    // Prüfungen
+    expect($matrix)->toBeInstanceOf(QrCodeMatrix::class);
+
+    // Prüfe die Größe (Version 2 = 25x25)
+    $expectedSize = 25; // 21 + (2-1)*4 = 25
+    expect($matrix->getSize())->toBe($expectedSize);
+
+    // Prüfe, ob Finder-Patterns vorhanden sind (3 Ecken haben spezifische Muster)
+    $topLeft = $this->hasFinderPattern($matrix->getMatrix(), 0, 0);
+    $topRight = $this->hasFinderPattern($matrix->getMatrix(), 0, $expectedSize - 7);
+    $bottomLeft = $this->hasFinderPattern($matrix->getMatrix(), $expectedSize - 7, 0);
+
+    expect($topLeft)->toBeTrue('Finder Pattern oben links fehlt');
+    expect($topRight)->toBeTrue('Finder Pattern oben rechts fehlt');
+    expect($bottomLeft)->toBeTrue('Finder Pattern unten links fehlt');
+});
+
+// Hilfsfunktion zur Prüfung von Finder-Patterns
+function hasFinderPattern(array $matrix, int $startRow, int $startCol): bool
+{
+    // Prüfe das 7x7 Finder-Pattern-Muster
+    // Das äußere Quadrat sollte 7x7 sein und vollständig dunkel
+    for ($i = 0; $i < 7; $i++) {
+        for ($j = 0; $j < 7; $j++) {
+            if ($i === 0 || $i === 6 || $j === 0 || $j === 6) {
+                if ($matrix[$startRow + $i][$startCol + $j] !== true) {
+                    return false;
+                }
+            }
+        }
+    }
+
+    // Das mittlere Quadrat sollte 5x5 sein und weiß (false)
+    for ($i = 1; $i < 6; $i++) {
+        for ($j = 1; $j < 6; $j++) {
+            if ($i === 1 || $i === 5 || $j === 1 || $j === 5) {
+                if ($matrix[$startRow + $i][$startCol + $j] !== false) {
+                    return false;
+                }
+            }
+        }
+    }
+
+    // Das innerste Quadrat sollte 3x3 sein und dunkel (true)
+    for ($i = 2; $i < 5; $i++) {
+        for ($j = 2; $j < 5; $j++) {
+            if ($matrix[$startRow + $i][$startCol + $j] !== true) {
+                return false;
+            }
+        }
+    }
+
+    return true;
+}
diff --git a/tests/Domain/QrCode/QrCodeTest.php b/tests/Domain/QrCode/QrCodeTest.php
new file mode 100644
index 00000000..8d0c5f8a
--- /dev/null
+++ b/tests/Domain/QrCode/QrCodeTest.php
@@ -0,0 +1,96 @@
+<?php
+
+declare(strict_types=1);
+
+use App\Domain\QrCode\QrCode;
+use App\Domain\QrCode\Exception\QrCodeException;
+use App\Domain\QrCode\Service\QrCodeEncoder;
+use App\Domain\QrCode\Service\QrCodeGenerator;
+use App\Domain\QrCode\Service\QrCodeMasker;
+use App\Domain\QrCode\Service\QrCodeRenderer;
+use App\Domain\QrCode\Service\ReedSolomon;
+use App\Domain\QrCode\ValueObject\ErrorCorrectionLevel;
+use App\Domain\QrCode\ValueObject\MaskPattern;
+use App\Domain\QrCode\ValueObject\QrCodeVersion;
+
+test('QrCode Objekt kann erstellt werden', function () {
+    $qrCode = new QrCode('Testdaten');
+
+    expect($qrCode->getData())->toBe('Testdaten');
+    expect($qrCode->getErrorCorrectionLevel())->toBe(ErrorCorrectionLevel::M);
+    expect($qrCode->getVersion())->toBeNull();
+});
+
+test('QrCode wirft Exception bei leeren Daten', function () {
+    expect(fn() => new QrCode(''))->toThrow(QrCodeException::class);
+});
+
+test('QrCode withMethods erzeugen neue Instanzen', function () {
+    $original = new QrCode('Test');
+    $withLevel = $original->withErrorCorrectionLevel(ErrorCorrectionLevel::H);
+    $withVersion = $original->withVersion(new QrCodeVersion(5));
+
+    expect($withLevel)->not->toBe($original);
+    expect($withVersion)->not->toBe($original);
+    expect($withLevel->getErrorCorrectionLevel())->toBe(ErrorCorrectionLevel::H);
+    expect($withVersion->getVersion()->getValue())->toBe(5);
+});
+
+test('MaskPattern kann Maskenbedingungen korrekt auswerten', function () {
+    $pattern = MaskPattern::PATTERN_0;
+
+    expect($pattern->shouldMask(0, 0))->toBeTrue(); // (0+0)%2 = 0
+    expect($pattern->shouldMask(1, 0))->toBeFalse(); // (1+0)%2 = 1
+    expect($pattern->shouldMask(1, 1))->toBeTrue(); // (1+1)%2 = 0
+});
+
+test('QrCodeEncoder kann Daten kodieren', function () {
+    $encoder = new QrCodeEncoder();
+    $qrCode = new QrCode('123');
+    $version = new QrCodeVersion(1);
+
+    $encoded = $encoder->encode($qrCode, $version);
+
+    expect($encoded)->toBeString();
+    expect(strlen($encoded))->toBeGreaterThan(0);
+});
+
+test('QrCodeGenerator kann QR-Code-Matrix generieren', function () {
+    $generator = new QrCodeGenerator(
+        new QrCodeEncoder(),
+        new QrCodeRenderer(new QrCodeMasker(), new ReedSolomon())
+    );
+
+    $qrCode = new QrCode('Test123');
+    $matrix = $generator->generate($qrCode);
+
+    expect($matrix->getSize())->toBeGreaterThan(20); // QR-Code ist mindestens Version 1 (21x21)
+});
+
+test('QrCodeMasker berechnet Maskenstrafen korrekt', function () {
+    $masker = new QrCodeMasker();
+    $size = 21; // Version 1
+
+    // Matrix mit alternierenden Modulen (geringe Strafe)
+    $alternatingMatrix = [];
+    for ($i = 0; $i < $size; $i++) {
+        $alternatingMatrix[$i] = [];
+        for ($j = 0; $j < $size; $j++) {
+            $alternatingMatrix[$i][$j] = ($i + $j) % 2 === 0;
+        }
+    }
+
+    // Matrix mit vielen aufeinanderfolgenden gleichen Modulen (hohe Strafe)
+    $repeatingMatrix = [];
+    for ($i = 0; $i < $size; $i++) {
+        $repeatingMatrix[$i] = [];
+        for ($j = 0; $j < $size; $j++) {
+            $repeatingMatrix[$i][$j] = $j < $size / 2;
+        }
+    }
+
+    $alternatingPenalty = $masker->calculateMaskPenalty($alternatingMatrix, $size);
+    $repeatingPenalty = $masker->calculateMaskPenalty($repeatingMatrix, $size);
+
+    expect($alternatingPenalty)->toBeLessThan($repeatingPenalty);
+});
diff --git a/tests/Domain/QrCode/Service/QrCodeEncoderTest.php b/tests/Domain/QrCode/Service/QrCodeEncoderTest.php
new file mode 100644
index 00000000..37e08862
--- /dev/null
+++ b/tests/Domain/QrCode/Service/QrCodeEncoderTest.php
@@ -0,0 +1,72 @@
+<?php
+
+declare(strict_types=1);
+
+use App\Domain\QrCode\QrCode;
+use App\Domain\QrCode\Service\QrCodeEncoder;
+use App\Domain\QrCode\ValueObject\ErrorCorrectionLevel;
+use App\Domain\QrCode\ValueObject\QrCodeVersion;
+
+test('QrCodeEncoder kann numerische Daten kodieren', function () {
+    $encoder = new QrCodeEncoder();
+    $qrCode = new QrCode('12345', ErrorCorrectionLevel::M);
+    $version = new QrCodeVersion(1);
+
+    $encoded = $encoder->encode($qrCode, $version);
+
+    // Prüfe, dass das Ergebnis ein binärer String ist
+    expect($encoded)->toBeString();
+    expect(strlen($encoded) % 8)->toBe(0); // Muss ein Vielfaches von 8 sein
+
+    // Prüfe den Mode Indicator für numerische Daten (0001)
+    expect(substr($encoded, 0, 4))->toBe('0001');
+});
+
+test('QrCodeEncoder kann alphanumerische Daten kodieren', function () {
+    $encoder = new QrCodeEncoder();
+    $qrCode = new QrCode('ABC123', ErrorCorrectionLevel::M);
+    $version = new QrCodeVersion(1);
+
+    $encoded = $encoder->encode($qrCode, $version);
+
+    // Prüfe, dass das Ergebnis ein binärer String ist
+    expect($encoded)->toBeString();
+    expect(strlen($encoded) % 8)->toBe(0); // Muss ein Vielfaches von 8 sein
+
+    // Prüfe den Mode Indicator für alphanumerische Daten (0010)
+    expect(substr($encoded, 0, 4))->toBe('0010');
+});
+
+test('QrCodeEncoder kann Byte-Daten kodieren', function () {
+    $encoder = new QrCodeEncoder();
+    $qrCode = new QrCode('Hello World!', ErrorCorrectionLevel::M);
+    $version = new QrCodeVersion(1);
+
+    $encoded = $encoder->encode($qrCode, $version);
+
+    // Prüfe, dass das Ergebnis ein binärer String ist
+    expect($encoded)->toBeString();
+    expect(strlen($encoded) % 8)->toBe(0); // Muss ein Vielfaches von 8 sein
+
+    // Prüfe den Mode Indicator für Byte-Daten (0100)
+    expect(substr($encoded, 0, 4))->toBe('0100');
+});
+
+test('QrCodeEncoder fügt Terminator und Padding korrekt hinzu', function () {
+    $encoder = new QrCodeEncoder();
+    $qrCode = new QrCode('1', ErrorCorrectionLevel::M); // Minimale Daten
+    $version = new QrCodeVersion(1);
+
+    $encoded = $encoder->encode($qrCode, $version);
+
+    // Prüfe, dass das Ergebnis ein binärer String ist
+    expect($encoded)->toBeString();
+
+    // Prüfe die Länge (sollte der vollen Datenkapazität entsprechen)
+    $expectedLength = (new QrCodeVersion(1))->getDataCapacity(ErrorCorrectionLevel::M) * 8;
+    expect(strlen($encoded))->toBe($expectedLength);
+
+    // Prüfe, ob Pad-Bytes vorhanden sind (11101100 oder 00010001)
+    $containsPadBytes = str_contains($encoded, '11101100') || str_contains($encoded, '00010001');
+    expect($containsPadBytes)->toBeTrue();
+});
diff --git a/tests/Domain/QrCode/Service/ReedSolomonTest.php b/tests/Domain/QrCode/Service/ReedSolomonTest.php
new file mode 100644
index 00000000..1eda7bfe
--- /dev/null
+++ b/tests/Domain/QrCode/Service/ReedSolomonTest.php
@@ -0,0 +1,84 @@
+<?php
+
+declare(strict_types=1);
+
+use App\Domain\QrCode\Service\ReedSolomon;
+use App\Domain\QrCode\Service\ReedSolomonEncoder;
+use App\Domain\QrCode\ValueObject\ErrorCorrectionLevel;
+
+test('ReedSolomon kann Fehlerkorrektur hinzufügen', function () {
+    $rs = new ReedSolomon();
+
+    // Erstelle einen einfachen Testfall mit 4 Datenbytes
+    $data = '00110011' . '01010101' . '11001100' . '10101010'; // Binär: 51, 85, 204, 170
+    $dataCapacity = 4; // 4 Bytes
+    $level = ErrorCorrectionLevel::M;
+
+    // Wende Reed-Solomon an
+    $encoded = $rs->addErrorCorrection($data, $dataCapacity, $level);
+
+    // Überprüfe, dass das Ergebnis länger als die Eingabe ist (ECC wurde hinzugefügt)
+    expect(strlen($encoded))->toBeGreaterThan(strlen($data));
+
+    // Überprüfe, dass die ursprünglichen Daten am Anfang vorhanden sind
+    expect(substr($encoded, 0, strlen($data)))->toBe($data);
+});
+
+test('ReedSolomonEncoder kann Bytes kodieren', function () {
+    $encoder = new ReedSolomonEncoder();
+
+    // Testdaten: [0x32, 0x54, 0x67, 0x89]
+    $data = [0x32, 0x54, 0x67, 0x89];
+    $eccLength = 4; // 4 ECC Bytes hinzufügen
+
+    $encoded = $encoder->encode($data, $eccLength);
+
+    // Erwarte Originaldaten + ECC-Bytes
+    expect(count($encoded))->toBe(count($data) + $eccLength);
+
+    // Überprüfe, dass die ursprünglichen Daten am Anfang vorhanden sind
+    for ($i = 0; $i < count($data); $i++) {
+        expect($encoded[$i])->toBe($data[$i]);
+    }
+
+    // Überprüfe, dass die ECC-Bytes nicht alle 0 sind (echte Berechnung)
+    $allZero = true;
+    for ($i = count($data); $i < count($encoded); $i++) {
+        if ($encoded[$i] !== 0) {
+            $allZero = false;
+            break;
+        }
+    }
+    expect($allZero)->toBeFalse();
+});
+
+test('ReedSolomon kann Daten in Blöcke organisieren', function () {
+    $rs = new ReedSolomon();
+    $method = new ReflectionMethod($rs, 'organizeDataBlocks');
+    $method->setAccessible(true);
+
+    // Testdaten: 8 Bytes [1, 2, 3, 4, 5, 6, 7, 8]
+    $data = [1, 2, 3, 4, 5, 6, 7, 8];
+    $version = 1;
+    $level = ErrorCorrectionLevel::M; // 1 Block für Version 1-M
+
+    $blocks = $method->invoke($rs, $data, $version, $level);
+
+    // Version 1-M hat 1 Block
+    expect(count($blocks))->toBe(1);
+    expect($blocks[0])->toBe($data);
+});
+
+test('ReedSolomon kann Blöcke interleaven', function () {
+    $rs = new ReedSolomon();
+    $method = new ReflectionMethod($rs, 'interleaveBlocks');
+    $method->setAccessible(true);
+
+    // 2 Blöcke: [1, 2, 3] und [4, 5, 6]
+    $blocks = [[1, 2, 3], [4, 5, 6]];
+
+    $interleaved = $method->invoke($rs, $blocks);
+
+    // Erwartetes Ergebnis: [1, 4, 2, 5, 3, 6]
+    expect($interleaved)->toBe([1, 4, 2, 5, 3, 6]);
+});
diff --git a/tests/Domain/QrCode/ValueObject/GaloisFieldTest.php b/tests/Domain/QrCode/ValueObject/GaloisFieldTest.php
new file mode 100644
index 00000000..c2513b85
--- /dev/null
+++ b/tests/Domain/QrCode/ValueObject/GaloisFieldTest.php
@@ -0,0 +1,59 @@
+<?php
+
+declare(strict_types=1);
+
+use App\Domain\QrCode\ValueObject\GaloisField;
+
+test('GaloisField Arithmetik funktioniert korrekt', function () {
+    $field = new GaloisField();
+
+    // Addition (XOR) Tests
+    expect($field->add(0, 0))->toBe(0);
+    expect($field->add(0, 1))->toBe(1);
+    expect($field->add(1, 0))->toBe(1);
+    expect($field->add(1, 1))->toBe(0);
+    expect($field->add(15, 32))->toBe(47);
+
+    // Multiplikation Tests
+    expect($field->multiply(0, 5))->toBe(0);
+    expect($field->multiply(5, 0))->toBe(0);
+    expect($field->multiply(1, 1))->toBe(1);
+    expect($field->multiply(2, 3))->toBe(6);
+
+    // Division Tests
+    expect($field->divide(0, 5))->toBe(0);
+    expect($field->divide(5, 1))->toBe(5);
+    expect($field->divide(6, 3))->toBe(2);
+
+    // Division durch Null sollte Exception werfen
+    expect(fn() => $field->divide(5, 0))->toThrow(\DivisionByZeroError::class);
+
+    // Potenzen Tests
+    expect($field->power(2, 0))->toBe(1);  // 2^0 = 1
+    expect($field->power(2, 1))->toBe(2);  // 2^1 = 2
+    expect($field->power(2, 2))->toBe(4);  // 2^2 = 4
+    expect($field->power(2, 3))->toBe(8);  // 2^3 = 8
+});
+
+test('GaloisField Tabellen sind korrekt initialisiert', function () {
+    $field = new GaloisField();
+
+    $expTable = $field->getExpTable();
+    $logTable = $field->getLogTable();
+
+    // Prüfe grundlegende Eigenschaften der Tabellen
+    expect(count($expTable))->toBe(256);
+    expect(count($logTable))->toBe(256);
+
+    // Prüfe spezifische Werte
+    expect($expTable[0])->toBe(1);
+    expect($expTable[1])->toBe(2);
+    expect($expTable[2])->toBe(4);
+    expect($expTable[3])->toBe(8);
+
+    // Prüfe Log-Tabelle
+    expect($logTable[1])->toBe(0);
+    expect($logTable[2])->toBe(1);
+    expect($logTable[4])->toBe(2);
+    expect($logTable[8])->toBe(3);
+});
diff --git a/tests/Domain/QrCode/ValueObject/PolynomialTest.php b/tests/Domain/QrCode/ValueObject/PolynomialTest.php
new file mode 100644
index 00000000..54ab359e
--- /dev/null
+++ b/tests/Domain/QrCode/ValueObject/PolynomialTest.php
@@ -0,0 +1,75 @@
+<?php
+
+declare(strict_types=1);
+
+use App\Domain\QrCode\ValueObject\GaloisField;
+use App\Domain\QrCode\ValueObject\Polynomial;
+
+test('Polynomial kann erstellt werden', function () {
+    $field = new GaloisField();
+    $poly = new Polynomial($field, [1, 2, 3]); // x^2 + 2x + 3
+
+    expect($poly->getCoefficients())->toBe([1, 2, 3]);
+    expect($poly->getDegree())->toBe(2);
+});
+
+test('Polynomial entfernt führende Nullen', function () {
+    $field = new GaloisField();
+    $poly = new Polynomial($field, [0, 0, 1, 2]); // x + 2
+
+    expect($poly->getCoefficients())->toBe([1, 2]);
+    expect($poly->getDegree())->toBe(1);
+});
+
+test('Polynomial kann an Stelle x ausgewertet werden', function () {
+    $field = new GaloisField();
+    $poly = new Polynomial($field, [1, 0, 1]); // x^2 + 1
+
+    expect($poly->evaluateAt(0))->toBe(1);
+    expect($poly->evaluateAt(1))->toBe(0); // 1^2 + 1 = 2 = 0 in GF(2)
+    expect($poly->evaluateAt(2))->toBe(5); // 2^2 + 1 = 5
+});
+
+test('Polynomial Addition funktioniert', function () {
+    $field = new GaloisField();
+    $poly1 = new Polynomial($field, [1, 2]); // x + 2
+    $poly2 = new Polynomial($field, [3, 4]); // 3x + 4
+
+    $sum = $poly1->add($poly2);
+
+    // In GF(2^8) ist Addition = XOR, daher 1⊕3=2, 2⊕4=6
+    expect($sum->getCoefficients())->toBe([2, 6]);
+});
+
+test('Polynomial Multiplikation funktioniert', function () {
+    $field = new GaloisField();
+    $poly1 = new Polynomial($field, [1, 1]); // x + 1
+    $poly2 = new Polynomial($field, [1, 0, 1]); // x^2 + 1
+
+    $product = $poly1->multiply($poly2);
+
+    // (x + 1)(x^2 + 1) = x^3 + x^2 + x + 1
+    expect($product->getCoefficients())->toBe([1, 1, 1, 1]);
+});
+
+test('Polynomial Division funktioniert', function () {
+    $field = new GaloisField();
+    $poly1 = new Polynomial($field, [1, 0, 1]); // x^2 + 1
+    $poly2 = new Polynomial($field, [1, 1]); // x + 1
+
+    $result = $poly1->divideAndRemainder($poly2);
+
+    // (x^2 + 1) ÷ (x + 1) = x - 1 + 2/(x+1)
+    // In GF(2^8): Quotient = x - 1 = x + 1, Rest = 2
+    expect($result['quotient']->getCoefficients())->toEqual([1, 1]);
+    expect($result['remainder']->getCoefficients())->toEqual([0]);
+});
+
+test('Generator Polynom kann korrekt erstellt werden', function () {
+    $field = new GaloisField();
+    $generator = Polynomial::buildGenerator($field, 3);
+
+    // Erwartetes Ergebnis für Grad 3
+    expect($generator->getDegree())->toBe(3);
+    expect(count($generator->getCoefficients()))->toBe(4);
+});
diff --git a/tests/Framework/DateTime/ClockInitializerTest.php b/tests/Framework/DateTime/ClockInitializerTest.php
new file mode 100644
index 00000000..88729800
--- /dev/null
+++ b/tests/Framework/DateTime/ClockInitializerTest.php
@@ -0,0 +1,54 @@
+<?php
+
+namespace Tests\Framework\DateTime;
+
+use App\Framework\DateTime\Clock;
+use App\Framework\DateTime\ClockInitializer;
+use App\Framework\DateTime\FrozenClock;
+use App\Framework\DateTime\SystemClock;
+
+class ClockInitializerTest extends \PHPUnit\Framework\TestCase
+{
+    public function testDefaultInitialization(): void
+    {
+        $initializer = new ClockInitializer();
+        $clock = $initializer();
+
+        $this->assertInstanceOf(SystemClock::class, $clock);
+        $this->assertEquals('UTC', $clock->now()->getTimezone()->getName());
+    }
+
+    public function testCustomTimezone(): void
+    {
+        $initializer = new ClockInitializer('Europe/Berlin');
+        $clock = $initializer();
+
+        $this->assertInstanceOf(SystemClock::class, $clock);
+        $this->assertEquals('Europe/Berlin', $clock->now()->getTimezone()->getName());
+    }
+
+    public function testFrozenClockInitialization(): void
+    {
+        $initializer = new ClockInitializer(
+            useFrozenClock: true,
+            frozenTime: '2021-01-01 12:00:00'
+        );
+        $clock = $initializer();
+
+        $this->assertInstanceOf(FrozenClock::class, $clock);
+        $this->assertEquals('2021-01-01 12:00:00', $clock->now()->format('Y-m-d H:i:s'));
+    }
+
+    public function testFrozenClockWithCustomTimezone(): void
+    {
+        $initializer = new ClockInitializer(
+            timezone: 'Europe/Berlin',
+            useFrozenClock: true,
+            frozenTime: '2021-01-01 12:00:00'
+        );
+        $clock = $initializer();
+
+        $this->assertInstanceOf(FrozenClock::class, $clock);
+        $this->assertEquals('Europe/Berlin', $clock->now()->getTimezone()->getName());
+    }
+}
diff --git a/tests/Framework/DateTime/DateRangeTest.php b/tests/Framework/DateTime/DateRangeTest.php
new file mode 100644
index 00000000..1433a349
--- /dev/null
+++ b/tests/Framework/DateTime/DateRangeTest.php
@@ -0,0 +1,101 @@
+<?php
+
+namespace Tests\Framework\DateTime;
+
+use App\Framework\DateTime\DateRange;
+
+class DateRangeTest extends \PHPUnit\Framework\TestCase
+{
+    public function testConstructorWithValidDates(): void
+    {
+        $start = new \DateTimeImmutable('2021-01-01');
+        $end = new \DateTimeImmutable('2021-01-31');
+
+        $range = new DateRange($start, $end);
+
+        $this->assertSame($start, $range->getStart());
+        $this->assertSame($end, $range->getEnd());
+    }
+
+    public function testConstructorWithInvalidDatesThrowsException(): void
+    {
+        $start = new \DateTimeImmutable('2021-01-31');
+        $end = new \DateTimeImmutable('2021-01-01');
+
+        $this->expectException(\InvalidArgumentException::class);
+        new DateRange($start, $end);
+    }
+
+    public function testFromStrings(): void
+    {
+        $range = DateRange::fromStrings('2021-01-01', '2021-01-31');
+
+        $this->assertEquals('2021-01-01', $range->getStart()->format('Y-m-d'));
+        $this->assertEquals('2021-01-31', $range->getEnd()->format('Y-m-d'));
+    }
+
+    public function testContains(): void
+    {
+        $range = DateRange::fromStrings('2021-01-01', '2021-01-31');
+
+        $inside = new \DateTimeImmutable('2021-01-15');
+        $onStart = new \DateTimeImmutable('2021-01-01');
+        $onEnd = new \DateTimeImmutable('2021-01-31');
+        $before = new \DateTimeImmutable('2020-12-31');
+        $after = new \DateTimeImmutable('2021-02-01');
+
+        $this->assertTrue($range->contains($inside));
+        $this->assertTrue($range->contains($onStart));
+        $this->assertTrue($range->contains($onEnd));
+        $this->assertFalse($range->contains($before));
+        $this->assertFalse($range->contains($after));
+    }
+
+    public function testContainsRange(): void
+    {
+        $mainRange = DateRange::fromStrings('2021-01-01', '2021-01-31');
+
+        $inside = DateRange::fromStrings('2021-01-10', '2021-01-20');
+        $sameRange = DateRange::fromStrings('2021-01-01', '2021-01-31');
+        $overlapping = DateRange::fromStrings('2021-01-15', '2021-02-15');
+        $outside = DateRange::fromStrings('2021-02-01', '2021-02-28');
+
+        $this->assertTrue($mainRange->containsRange($inside));
+        $this->assertTrue($mainRange->containsRange($sameRange));
+        $this->assertFalse($mainRange->containsRange($overlapping));
+        $this->assertFalse($mainRange->containsRange($outside));
+    }
+
+    public function testOverlaps(): void
+    {
+        $mainRange = DateRange::fromStrings('2021-01-01', '2021-01-31');
+
+        $inside = DateRange::fromStrings('2021-01-10', '2021-01-20');
+        $overlappingStart = DateRange::fromStrings('2020-12-15', '2021-01-15');
+        $overlappingEnd = DateRange::fromStrings('2021-01-15', '2021-02-15');
+        $outside = DateRange::fromStrings('2021-02-01', '2021-02-28');
+
+        $this->assertTrue($mainRange->overlaps($inside));
+        $this->assertTrue($mainRange->overlaps($overlappingStart));
+        $this->assertTrue($mainRange->overlaps($overlappingEnd));
+        $this->assertFalse($mainRange->overlaps($outside));
+    }
+
+    public function testGetDuration(): void
+    {
+        $range = DateRange::fromStrings('2021-01-01', '2021-01-31');
+        $duration = $range->getDuration();
+
+        $this->assertInstanceOf(\DateInterval::class, $duration);
+        $this->assertEquals(30, $duration->days);
+    }
+
+    public function testGetDurationInSeconds(): void
+    {
+        $range = DateRange::fromStrings('2021-01-01', '2021-01-02');
+        $seconds = $range->getDurationInSeconds();
+
+        // Ein Tag hat 86400 Sekunden
+        $this->assertEquals(86400, $seconds);
+    }
+}
diff --git a/tests/Framework/DateTime/DateTimeFormatterTest.php b/tests/Framework/DateTime/DateTimeFormatterTest.php
new file mode 100644
index 00000000..248132ef
--- /dev/null
+++ b/tests/Framework/DateTime/DateTimeFormatterTest.php
@@ -0,0 +1,64 @@
+<?php
+
+namespace Tests\Framework\DateTime;
+
+use App\Framework\DateTime\DateTimeFormatter;
+
+class DateTimeFormatterTest extends \PHPUnit\Framework\TestCase
+{
+    private \DateTimeImmutable $sampleDate;
+    private DateTimeFormatter $formatter;
+
+    protected function setUp(): void
+    {
+        $this->sampleDate = new \DateTimeImmutable('2021-01-01 12:34:56', new \DateTimeZone('UTC'));
+        $this->formatter = new DateTimeFormatter();
+    }
+
+    public function testFormatIso8601(): void
+    {
+        $formatted = $this->formatter->formatIso8601($this->sampleDate);
+        $this->assertEquals('2021-01-01T12:34:56+00:00', $formatted);
+    }
+
+    public function testFormatSql(): void
+    {
+        $formatted = $this->formatter->formatSql($this->sampleDate);
+        $this->assertEquals('2021-01-01 12:34:56', $formatted);
+    }
+
+    public function testFormatDate(): void
+    {
+        $formatted = $this->formatter->formatDate($this->sampleDate);
+        $this->assertEquals('2021-01-01', $formatted);
+    }
+
+    public function testFormatTime(): void
+    {
+        $formatted = $this->formatter->formatTime($this->sampleDate);
+        $this->assertEquals('12:34:56', $formatted);
+    }
+
+    public function testCustomFormat(): void
+    {
+        $formatted = $this->formatter->format($this->sampleDate, 'd.m.Y H:i');
+        $this->assertEquals('01.01.2021 12:34', $formatted);
+    }
+
+    public function testWithCustomTimezone(): void
+    {
+        $formatter = new DateTimeFormatter('Europe/Berlin');
+        $formatted = $formatter->format($this->sampleDate, 'Y-m-d H:i:s T');
+
+        // UTC 12:34:56 sollte in Berlin 13:34:56 sein (während Standardzeit/Winterzeit)
+        $this->assertEquals('2021-01-01 13:34:56 CET', $formatted);
+    }
+
+    public function testWithDateTimeObject(): void
+    {
+        $dateTime = new \DateTime('2021-01-01 12:34:56', new \DateTimeZone('UTC'));
+        $formatted = $this->formatter->formatIso8601($dateTime);
+
+        $this->assertEquals('2021-01-01T12:34:56+00:00', $formatted);
+    }
+}
diff --git a/tests/Framework/DateTime/DateTimeTest.php b/tests/Framework/DateTime/DateTimeTest.php
new file mode 100644
index 00000000..806209cc
--- /dev/null
+++ b/tests/Framework/DateTime/DateTimeTest.php
@@ -0,0 +1,138 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tests\Framework\DateTime;
+
+use App\Framework\DateTime\DateTime;
+use App\Framework\DateTime\Exceptions\InvalidDateTimeException;
+use App\Framework\DateTime\Exceptions\InvalidTimezoneException;
+use PHPUnit\Framework\TestCase;
+
+class DateTimeTest extends TestCase
+{
+    protected function setUp(): void
+    {
+        // Sicherheitsvorkehrung: Default-Timezone vor jedem Test zurücksetzen
+        if (method_exists(DateTime::class, 'setDefaultTimezone')) {
+            DateTime::setDefaultTimezone('UTC');
+        }
+    }
+
+    public function testNowReturnsCurrentDateTime(): void
+    {
+        $now = DateTime::now();
+
+        $this->assertInstanceOf(\DateTimeImmutable::class, $now);
+        $this->assertEquals('UTC', $now->getTimezone()->getName());
+        $this->assertLessThanOrEqual(2, abs(time() - $now->getTimestamp()));
+    }
+
+    public function testFromTimestamp(): void
+    {
+        $timestamp = 1609459200; // 2021-01-01 00:00:00 UTC
+        $date = DateTime::fromTimestamp($timestamp);
+
+        $this->assertEquals($timestamp, $date->getTimestamp());
+        $this->assertEquals('UTC', $date->getTimezone()->getName());
+    }
+
+    public function testFromString(): void
+    {
+        $date = DateTime::fromString('2021-01-01 12:00:00');
+
+        $this->assertEquals('2021-01-01 12:00:00', $date->format('Y-m-d H:i:s'));
+        $this->assertEquals('UTC', $date->getTimezone()->getName());
+    }
+
+    public function testFromFormat(): void
+    {
+        $date = DateTime::fromFormat('01/01/2021', 'd/m/Y');
+
+        $this->assertEquals('2021-01-01', $date->format('Y-m-d'));
+    }
+
+    public function testFromDateTime(): void
+    {
+        $originalDate = new \DateTime('2021-01-01 12:00:00');
+        $immutableDate = DateTime::fromDateTime($originalDate);
+
+        $this->assertInstanceOf(\DateTimeImmutable::class, $immutableDate);
+        $this->assertEquals($originalDate->format('Y-m-d H:i:s'), $immutableDate->format('Y-m-d H:i:s'));
+    }
+
+    public function testCreateInterval(): void
+    {
+        $interval = DateTime::createInterval('P1D');
+
+        $this->assertInstanceOf(\DateInterval::class, $interval);
+        $this->assertEquals(1, $interval->d);
+    }
+
+    public function testCreateTimezone(): void
+    {
+        $timezone = DateTime::createTimezone('Europe/Berlin');
+
+        $this->assertInstanceOf(\DateTimeZone::class, $timezone);
+        $this->assertEquals('Europe/Berlin', $timezone->getName());
+    }
+
+    public function testInvalidTimezoneThrowsException(): void
+    {
+        $this->expectException(InvalidTimezoneException::class);
+        DateTime::createTimezone('Invalid/Timezone');
+    }
+
+    public function testInvalidDateTimeThrowsException(): void
+    {
+        $this->expectException(InvalidDateTimeException::class);
+        DateTime::fromString('not a date');
+    }
+
+    public function testInvalidFormatThrowsException(): void
+    {
+        $this->expectException(InvalidDateTimeException::class);
+        DateTime::fromFormat('2021-01-01', 'invalid format');
+    }
+
+    public function testInvalidIntervalThrowsException(): void
+    {
+        $this->expectException(InvalidDateTimeException::class);
+        DateTime::createInterval('invalid interval');
+    }
+
+    public function testSetDefaultTimezone(): void
+    {
+        DateTime::setDefaultTimezone('Europe/Berlin');
+        $now = DateTime::now();
+
+        $this->assertEquals('Europe/Berlin', $now->getTimezone()->getName());
+    }
+
+    public function testToday(): void
+    {
+        $today = DateTime::today();
+        $expected = (new \DateTimeImmutable('today'))->format('Y-m-d');
+
+        $this->assertEquals($expected, $today->format('Y-m-d'));
+        $this->assertEquals('00:00:00', $today->format('H:i:s'));
+    }
+
+    public function testTomorrow(): void
+    {
+        $tomorrow = DateTime::tomorrow();
+        $expected = (new \DateTimeImmutable('tomorrow'))->format('Y-m-d');
+
+        $this->assertEquals($expected, $tomorrow->format('Y-m-d'));
+        $this->assertEquals('00:00:00', $tomorrow->format('H:i:s'));
+    }
+
+    public function testYesterday(): void
+    {
+        $yesterday = DateTime::yesterday();
+        $expected = (new \DateTimeImmutable('yesterday'))->format('Y-m-d');
+
+        $this->assertEquals($expected, $yesterday->format('Y-m-d'));
+        $this->assertEquals('00:00:00', $yesterday->format('H:i:s'));
+    }
+}
diff --git a/tests/Framework/DateTime/FrozenClockTest.php b/tests/Framework/DateTime/FrozenClockTest.php
new file mode 100644
index 00000000..fe80a2a2
--- /dev/null
+++ b/tests/Framework/DateTime/FrozenClockTest.php
@@ -0,0 +1,82 @@
+<?php
+
+namespace Tests\Framework\DateTime;
+
+use App\Framework\DateTime\FrozenClock;
+
+class FrozenClockTest extends \PHPUnit\Framework\TestCase
+{
+    public function testNowReturnsFrozenTime(): void
+    {
+        $frozenTime = new \DateTimeImmutable('2021-01-01 00:00:00');
+        $clock = new FrozenClock($frozenTime);
+
+        $this->assertEquals($frozenTime, $clock->now());
+
+        // Überprüfen, dass die Zeit eingefroren ist
+        sleep(1);
+        $this->assertEquals($frozenTime, $clock->now());
+    }
+
+    public function testFromTimestampReturnsCorrectDateTime(): void
+    {
+        $clock = new FrozenClock('2021-01-01 00:00:00');
+        $timestamp = 1609459200; // 2021-01-01 00:00:00 UTC
+        $date = $clock->fromTimestamp($timestamp);
+
+        $this->assertInstanceOf(\DateTimeImmutable::class, $date);
+        $this->assertEquals($timestamp, $date->getTimestamp());
+    }
+
+    public function testFromStringReturnsCorrectDateTime(): void
+    {
+        $clock = new FrozenClock('2021-01-01 00:00:00');
+        $date = $clock->fromString('2021-02-01 00:00:00');
+
+        $this->assertInstanceOf(\DateTimeImmutable::class, $date);
+        $this->assertEquals('2021-02-01', $date->format('Y-m-d'));
+        $this->assertEquals('00:00:00', $date->format('H:i:s'));
+    }
+
+    public function testSetToChangesTime(): void
+    {
+        $clock = new FrozenClock('2021-01-01 00:00:00');
+        $newTime = new \DateTimeImmutable('2021-02-01 00:00:00');
+
+        $clock->setTo($newTime);
+        $this->assertEquals($newTime, $clock->now());
+
+        $clock->setTo('2021-03-01 00:00:00');
+        $this->assertEquals('2021-03-01', $clock->now()->format('Y-m-d'));
+    }
+
+    public function testMoveForwardAdvancesTime(): void
+    {
+        $clock = new FrozenClock('2021-01-01 00:00:00');
+
+        $clock->moveForward('P1D'); // 1 Tag vorwärts
+        $this->assertEquals('2021-01-02', $clock->now()->format('Y-m-d'));
+
+        $clock->moveForward('PT1H'); // 1 Stunde vorwärts
+        $this->assertEquals('2021-01-02 01:00:00', $clock->now()->format('Y-m-d H:i:s'));
+    }
+
+    public function testMoveBackwardReversesTime(): void
+    {
+        $clock = new FrozenClock('2021-01-10 10:00:00');
+
+        $clock->moveBackward('P5D'); // 5 Tage zurück
+        $this->assertEquals('2021-01-05', $clock->now()->format('Y-m-d'));
+
+        $clock->moveBackward('PT5H'); // 5 Stunden zurück
+        $this->assertEquals('2021-01-05 05:00:00', $clock->now()->format('Y-m-d H:i:s'));
+    }
+
+    public function testCustomTimezone(): void
+    {
+        $clock = new FrozenClock('2021-01-01 00:00:00', 'Europe/Berlin');
+        $now = $clock->now();
+
+        $this->assertEquals('Europe/Berlin', $now->getTimezone()->getName());
+    }
+}
diff --git a/tests/Framework/DateTime/SystemClockTest.php b/tests/Framework/DateTime/SystemClockTest.php
new file mode 100644
index 00000000..4c5f9df5
--- /dev/null
+++ b/tests/Framework/DateTime/SystemClockTest.php
@@ -0,0 +1,66 @@
+<?php
+
+namespace Tests\Framework\DateTime;
+
+use App\Framework\DateTime\SystemClock;
+
+class SystemClockTest extends \PHPUnit\Framework\TestCase
+{
+    public function testNowReturnsCurrentDateTime(): void
+    {
+        $clock = new SystemClock();
+        $now = $clock->now();
+
+        $this->assertInstanceOf(\DateTimeImmutable::class, $now);
+        $this->assertEquals('UTC', $now->getTimezone()->getName());
+
+        // Überprüfen, dass das Datum innerhalb von 2 Sekunden liegt (für Testlaufzeit)
+        $this->assertLessThanOrEqual(2, abs(time() - $now->getTimestamp()));
+    }
+
+    public function testFromTimestampReturnsCorrectDateTime(): void
+    {
+        $clock = new SystemClock();
+        $timestamp = 1609459200; // 2021-01-01 00:00:00 UTC
+        $date = $clock->fromTimestamp($timestamp);
+
+        $this->assertInstanceOf(\DateTimeImmutable::class, $date);
+        $this->assertEquals($timestamp, $date->getTimestamp());
+        $this->assertEquals('UTC', $date->getTimezone()->getName());
+    }
+
+    public function testFromStringReturnsCorrectDateTime(): void
+    {
+        $clock = new SystemClock();
+        $date = $clock->fromString('2021-01-01 00:00:00');
+
+        $this->assertInstanceOf(\DateTimeImmutable::class, $date);
+        $this->assertEquals('2021-01-01', $date->format('Y-m-d'));
+        $this->assertEquals('00:00:00', $date->format('H:i:s'));
+    }
+
+    public function testFromStringWithFormatReturnsCorrectDateTime(): void
+    {
+        $clock = new SystemClock();
+        $date = $clock->fromString('01/01/2021', 'd/m/Y');
+
+        $this->assertInstanceOf(\DateTimeImmutable::class, $date);
+        $this->assertEquals('2021-01-01', $date->format('Y-m-d'));
+    }
+
+    public function testFromStringWithInvalidFormatThrowsException(): void
+    {
+        $clock = new SystemClock();
+
+        $this->expectException(\Exception::class);
+        $clock->fromString('not a date', 'Y-m-d');
+    }
+
+    public function testClockWithCustomTimezone(): void
+    {
+        $clock = new SystemClock('Europe/Berlin');
+        $now = $clock->now();
+
+        $this->assertEquals('Europe/Berlin', $now->getTimezone()->getName());
+    }
+}
diff --git a/tests/Framework/Filesystem/FileStorageTest.php b/tests/Framework/Filesystem/FileStorageTest.php
new file mode 100644
index 00000000..639ff168
--- /dev/null
+++ b/tests/Framework/Filesystem/FileStorageTest.php
@@ -0,0 +1,70 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tests\Framework\Filesystem;
+
+use App\Framework\Filesystem\Exceptions\FileNotFoundException;
+use App\Framework\Filesystem\FileStorage;
+use App\Framework\Filesystem\InMemoryStorage;
+
+test('speichert und lädt Dateien', function () {
+    $tempFile = tempnam(sys_get_temp_dir(), 'test_');
+    $content = 'Testinhalt ' . uniqid();
+
+    $storage = new FileStorage();
+    $storage->put($tempFile, $content);
+
+    expect($storage->exists($tempFile))->toBeTrue();
+    expect($storage->get($tempFile))->toBe($content);
+    expect($storage->size($tempFile))->toBe(strlen($content));
+
+    // Aufräumen
+    $storage->delete($tempFile);
+    expect($storage->exists($tempFile))->toBeFalse();
+});
+
+test('wirft Exception bei nicht existierender Datei', function () {
+    $storage = new FileStorage();
+    $nonExistingFile = '/tmp/doesnt_exist_' . uniqid();
+
+    expect(fn() => $storage->get($nonExistingFile))
+        ->toThrow(FileNotFoundException::class);
+});
+
+test('kopiert Dateien', function () {
+    $tempFile = tempnam(sys_get_temp_dir(), 'src_');
+    $destFile = tempnam(sys_get_temp_dir(), 'dest_');
+    unlink($destFile); // Löschen, damit copy funktioniert
+
+    $content = 'Kopierinhalt ' . uniqid();
+
+    $storage = new FileStorage();
+    $storage->put($tempFile, $content);
+    $storage->copy($tempFile, $destFile);
+
+    expect($storage->exists($destFile))->toBeTrue();
+    expect($storage->get($destFile))->toBe($content);
+
+    // Aufräumen
+    $storage->delete($tempFile);
+    $storage->delete($destFile);
+});
+
+test('InMemoryStorage funktioniert wie FileStorage', function () {
+    $storage = new InMemoryStorage();
+    $path = '/virtual/test.txt';
+    $content = 'Virtueller Inhalt';
+
+    $storage->put($path, $content);
+    expect($storage->exists($path))->toBeTrue();
+    expect($storage->get($path))->toBe($content);
+    expect($storage->size($path))->toBe(strlen($content));
+
+    $copyPath = '/virtual/copy.txt';
+    $storage->copy($path, $copyPath);
+    expect($storage->get($copyPath))->toBe($content);
+
+    $storage->delete($path);
+    expect($storage->exists($path))->toBeFalse();
+});
diff --git a/tests/Framework/Filesystem/LazyLoadingTest.php b/tests/Framework/Filesystem/LazyLoadingTest.php
new file mode 100644
index 00000000..2cae3d79
--- /dev/null
+++ b/tests/Framework/Filesystem/LazyLoadingTest.php
@@ -0,0 +1,121 @@
+<?php
+declare(strict_types=1);
+
+namespace Tests\Framework\Filesystem;
+
+use App\Framework\Filesystem\File;
+use App\Framework\Filesystem\Directory;
+use App\Framework\Filesystem\FilesystemFactory;
+use App\Framework\Filesystem\InMemoryStorage;
+use App\Framework\Filesystem\FileStorage;
+
+it('lädt File-Properties erst bei Bedarf', function() {
+    // Test-Storage mit Instrumentierung
+    $storage = new class extends InMemoryStorage {
+        public array $accessed = [];
+
+        public function get(string $path): string {
+            $this->accessed[] = "get:{$path}";
+            return parent::get($path);
+        }
+
+        public function size(string $path): int {
+            $this->accessed[] = "size:{$path}";
+            return parent::size($path);
+        }
+    };
+
+    // Testdatei hinzufügen
+    $storage->addFile('/test.txt', 'Testinhalt');
+
+    // Lazy File erstellen
+    $file = $storage->file('/test.txt');
+
+    // Sollte noch keine Storage-Methoden aufgerufen haben
+    expect($storage->accessed)->toBeEmpty();
+
+    // Zugriff auf path sollte kein Laden auslösen
+    $path = $file->path;
+    expect($storage->accessed)->toBeEmpty();
+
+    // Zugriff auf contents sollte get() auslösen
+    $contents = $file->contents;
+    expect($storage->accessed)->toContain('get:/test.txt');
+    expect($contents)->toBe('Testinhalt');
+
+    // Zugriff auf size sollte size() auslösen
+    $size = $file->size;
+    expect($storage->accessed)->toContain('size:/test.txt');
+    expect($size)->toBe(10); // Länge von 'Testinhalt'
+});
+
+it('lädt Directory-Properties erst bei Bedarf', function() {
+    // Test-Storage mit Instrumentierung
+    $storage = new class extends InMemoryStorage {
+        public array $accessed = [];
+
+        public function listDirectory(string $directory): array {
+            $this->accessed[] = "list:{$directory}";
+            return parent::listDirectory($directory);
+        }
+    };
+
+    // Testverzeichnis erstellen
+    $storage->createDirectory('/test-dir');
+    $storage->addFile('/test-dir/file1.txt', 'Datei 1');
+    $storage->addFile('/test-dir/file2.txt', 'Datei 2');
+
+    // Lazy Directory erstellen
+    $dir = $storage->directory('/test-dir');
+
+    // Sollte noch keine Storage-Methoden aufgerufen haben
+    expect($storage->accessed)->toBeEmpty();
+
+    // Zugriff auf path sollte kein Laden auslösen
+    $path = $dir->path;
+    expect($storage->accessed)->toBeEmpty();
+
+    // Zugriff auf contents sollte listDirectory() auslösen
+    $contents = $dir->contents;
+    expect($storage->accessed)->toContain('list:/test-dir');
+    expect($contents)->toHaveCount(2);
+});
+
+it('kann mit echtem FileStorage arbeiten', function() {
+    // Dieser Test kann übersprungen werden, wenn keine Schreibrechte im Temp-Verzeichnis vorhanden sind
+    $tempDir = sys_get_temp_dir() . '/php-lazy-test-' . uniqid();
+    @mkdir($tempDir, 0777, true);
+    if (!is_dir($tempDir) || !is_writable($tempDir)) {
+        $this->markTestSkipped('Kein Schreibzugriff im Temp-Verzeichnis');
+    }
+
+    try {
+        // Echten FileStorage verwenden
+        $storage = new FileStorage();
+
+        // Testdatei erstellen
+        $testFile = $tempDir . '/test.txt';
+        file_put_contents($testFile, 'Lazy Loading Test');
+
+        // Lazy File erstellen
+        $file = $storage->file($testFile);
+
+        // Properties testen
+        expect($file->path)->toBe($testFile);
+        expect($file->contents)->toBe('Lazy Loading Test');
+        expect($file->size)->toBe(17); // Länge von 'Lazy Loading Test'
+        expect($file->lastModified)->toBeGreaterThan(time() - 10);
+
+        // Directory testen
+        $dir = $storage->directory($tempDir);
+        expect($dir->exists())->toBeTrue();
+
+        $files = $dir->getFiles();
+        expect($files)->toHaveCount(1);
+        expect($files[0]->path)->toEndWith('/test.txt');
+    } finally {
+        // Aufräumen
+        @unlink($testFile);
+        @rmdir($tempDir);
+    }
+});
diff --git a/tests/Framework/StaticSite/RouteCollectorTest.php b/tests/Framework/StaticSite/RouteCollectorTest.php
new file mode 100644
index 00000000..5f0b1c60
--- /dev/null
+++ b/tests/Framework/StaticSite/RouteCollectorTest.php
@@ -0,0 +1,79 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tests\Framework\StaticSite;
+
+use App\Framework\Router\HttpRouter;
+use App\Framework\Router\Route;
+use App\Framework\Router\RouteCollection;
+use App\Framework\StaticSite\RouteCollector;
+use PHPUnit\Framework\TestCase;
+
+class RouteCollectorTest extends TestCase
+{
+    public function testCollectRoutes(): void
+    {
+        // Testdaten vorbereiten
+        $routes = [
+            new Route(path: '/', controller: 'TestController', action: 'index', methods: ['GET']),
+            new Route(path: '/about', controller: 'TestController', action: 'about', methods: ['GET']),
+            new Route(path: '/api/data', controller: 'ApiController', action: 'getData', methods: ['GET']),
+            new Route(path: '/contact', controller: 'TestController', action: 'contact', methods: ['POST']),
+            new Route(path: '/users/{id}', controller: 'UserController', action: 'show', methods: ['GET']),
+        ];
+
+        $routeCollection = $this->createMock(RouteCollection::class);
+        $routeCollection->method('getAll')->willReturn($routes);
+
+        $router = $this->createMock(HttpRouter::class);
+        $router->method('getRoutes')->willReturn($routeCollection);
+
+        // RouteCollector initialisieren
+        $collector = new RouteCollector($router);
+
+        // Routen sammeln
+        $collectedRoutes = $collector->collectRoutes();
+
+        // Prüfen, ob die richtigen Routen gesammelt wurden (nur GET-Methoden)
+        $this->assertContains('/', $collectedRoutes);
+        $this->assertContains('/about', $collectedRoutes);
+        $this->assertContains('/api/data', $collectedRoutes);
+        $this->assertContains('/users/{id}', $collectedRoutes);
+        $this->assertNotContains('/contact', $collectedRoutes); // POST-Route sollte nicht enthalten sein
+    }
+
+    public function testFilterRoutes(): void
+    {
+        // Testdaten vorbereiten
+        $routes = [
+            '/',
+            '/about',
+            '/api/data',
+            '/api/users',
+            '/admin/dashboard',
+            '/users/{id}',
+            '/products/{slug}',
+        ];
+
+        $excludePatterns = [
+            '/\/api\/.*/',    // API-Routen ausschließen
+            '/\/admin\/.*/', // Admin-Routen ausschließen
+        ];
+
+        $router = $this->createMock(HttpRouter::class);
+        $collector = new RouteCollector($router);
+
+        // Routen filtern
+        $filteredRoutes = $collector->filterRoutes($routes, $excludePatterns);
+
+        // Prüfen, ob die richtigen Routen gefiltert wurden
+        $this->assertContains('/', $filteredRoutes);
+        $this->assertContains('/about', $filteredRoutes);
+        $this->assertNotContains('/api/data', $filteredRoutes);    // Sollte durch Pattern ausgeschlossen sein
+        $this->assertNotContains('/api/users', $filteredRoutes);   // Sollte durch Pattern ausgeschlossen sein
+        $this->assertNotContains('/admin/dashboard', $filteredRoutes); // Sollte durch Pattern ausgeschlossen sein
+        $this->assertNotContains('/users/{id}', $filteredRoutes);      // Sollte durch Platzhalter ausgeschlossen sein
+        $this->assertNotContains('/products/{slug}', $filteredRoutes);  // Sollte durch Platzhalter ausgeschlossen sein
+    }
+}
diff --git a/tests/Framework/StaticSite/StaticPageCollectorTest.php b/tests/Framework/StaticSite/StaticPageCollectorTest.php
new file mode 100644
index 00000000..550d9af8
--- /dev/null
+++ b/tests/Framework/StaticSite/StaticPageCollectorTest.php
@@ -0,0 +1,102 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tests\Framework\StaticSite;
+
+use App\Framework\Attributes\StaticPage;
+use App\Framework\Router\HttpRouter;
+use App\Framework\Router\Route;
+use App\Framework\Router\RouteCollection;
+use App\Framework\StaticSite\StaticPageCollector;
+use PHPUnit\Framework\TestCase;
+
+class StaticPageCollectorTest extends TestCase
+{
+    public function testCollectStaticPages(): void
+    {
+        // Controller-Klasse mit StaticPage-Attribut simulieren
+        $controllerClass = 'TestStaticPageController';
+        $this->createTestControllerClass($controllerClass);
+
+        // Testdaten vorbereiten
+        $routes = [
+            new Route(path: '/', controller: $controllerClass, action: 'indexAction', methods: ['GET']),
+            new Route(path: '/about', controller: $controllerClass, action: 'aboutAction', methods: ['GET']),
+            new Route(path: '/contact', controller: $controllerClass, action: 'contactAction', methods: ['GET']),
+            new Route(path: '/api/data', controller: 'ApiController', action: 'getData', methods: ['GET']),
+        ];
+
+        $routeCollection = $this->createMock(RouteCollection::class);
+        $routeCollection->method('getAll')->willReturn($routes);
+
+        $router = $this->createMock(HttpRouter::class);
+        $router->method('getRoutes')->willReturn($routeCollection);
+
+        // StaticPageCollector initialisieren
+        $collector = new StaticPageCollector($router);
+
+        // Statische Seiten sammeln
+        $staticPages = $collector->collectStaticPages();
+
+        // Prüfen, ob die richtigen Seiten gesammelt wurden
+        $this->assertContains('/', $staticPages);
+        $this->assertContains('/about', $staticPages);
+        $this->assertNotContains('/contact', $staticPages); // Kein StaticPage-Attribut
+        $this->assertNotContains('/api/data', $staticPages); // Anderer Controller ohne StaticPage-Attribut
+    }
+
+    public function testCollectAllGetRoutes(): void
+    {
+        // Testdaten vorbereiten
+        $routes = [
+            new Route(path: '/', controller: 'TestController', action: 'index', methods: ['GET']),
+            new Route(path: '/about', controller: 'TestController', action: 'about', methods: ['GET']),
+            new Route(path: '/contact', controller: 'TestController', action: 'contact', methods: ['POST']),
+            new Route(path: '/api/data', controller: 'ApiController', action: 'getData', methods: ['GET']),
+        ];
+
+        $routeCollection = $this->createMock(RouteCollection::class);
+        $routeCollection->method('getAll')->willReturn($routes);
+
+        $router = $this->createMock(HttpRouter::class);
+        $router->method('getRoutes')->willReturn($routeCollection);
+
+        // StaticPageCollector initialisieren
+        $collector = new StaticPageCollector($router);
+
+        // Alle GET-Routen sammeln
+        $allGetRoutes = $collector->collectAllGetRoutes();
+
+        // Prüfen, ob die richtigen Seiten gesammelt wurden
+        $this->assertContains('/', $allGetRoutes);
+        $this->assertContains('/about', $allGetRoutes);
+        $this->assertContains('/api/data', $allGetRoutes);
+        $this->assertNotContains('/contact', $allGetRoutes); // POST-Route sollte nicht enthalten sein
+    }
+
+    /**
+     * Erstellt eine temporäre Controller-Klasse mit StaticPage-Attributen für Tests
+     */
+    private function createTestControllerClass(string $className): void
+    {
+        if (class_exists($className)) {
+            return;
+        }
+
+        $code = <<<EOT
+        class {$className} {
+            #[\App\Framework\Attributes\StaticPage]
+            public function indexAction() {}
+
+            #[\App\Framework\Attributes\StaticPage(outputPath: 'custom-about')]
+            public function aboutAction() {}
+
+            // Keine StaticPage-Annotation
+            public function contactAction() {}
+        }
+        EOT;
+
+        eval($code);
+    }
+}
diff --git a/tests/Framework/StaticSite/StaticSiteGeneratorTest.php b/tests/Framework/StaticSite/StaticSiteGeneratorTest.php
new file mode 100644
index 00000000..779c3935
--- /dev/null
+++ b/tests/Framework/StaticSite/StaticSiteGeneratorTest.php
@@ -0,0 +1,134 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tests\Framework\StaticSite;
+
+use App\Framework\Core\Application;
+use App\Framework\Http\Method;
+use App\Framework\Http\HttpResponse;
+use App\Framework\Http\Request;
+use App\Framework\Http\Response;
+use App\Framework\StaticSite\StaticSiteGenerator;
+use PHPUnit\Framework\TestCase;
+
+class StaticSiteGeneratorTest extends TestCase
+{
+    private $outputDir;
+    private $app;
+
+    protected function setUp(): void
+    {
+        parent::setUp();
+
+        // Temporäres Verzeichnis für Tests erstellen
+        $this->outputDir = sys_get_temp_dir() . '/static-site-test-' . uniqid();
+        mkdir($this->outputDir, 0755, true);
+
+        // Mock für Application erstellen
+        $this->app = $this->createMock(Application::class);
+    }
+
+    protected function tearDown(): void
+    {
+        parent::tearDown();
+
+        // Temporäres Verzeichnis nach dem Test löschen
+        $this->removeDirectory($this->outputDir);
+    }
+
+    /**
+     * Hilfsfunktion zum rekursiven Löschen eines Verzeichnisses
+     */
+    private function removeDirectory(string $dir): void
+    {
+        if (!is_dir($dir)) {
+            return;
+        }
+
+        $files = array_diff(scandir($dir), ['.', '..']);
+
+        foreach ($files as $file) {
+            $path = $dir . '/' . $file;
+            is_dir($path) ? $this->removeDirectory($path) : unlink($path);
+        }
+
+        rmdir($dir);
+    }
+
+    public function testGenerateCreatesStaticFiles(): void
+    {
+        // Testdaten vorbereiten
+        $routes = ['/', '/about', '/blog/post-1'];
+        $responseBody = '<html><body>Test Content</body></html>';
+
+        // Mock für Response konfigurieren
+        $response = $this->createMock(Response::class);
+        $response->method('getBody')->willReturn($responseBody);
+
+        // App-Mock konfigurieren, um Response zurückzugeben
+        $this->app->method('handleRequest')->willReturn($response);
+
+        // StaticSiteGenerator initialisieren
+        $generator = new StaticSiteGenerator($this->app, $routes, $this->outputDir);
+
+        // Statische Seiten generieren
+        $generator->generate();
+
+        // Prüfen, ob die erwarteten Dateien erstellt wurden
+        $this->assertFileExists($this->outputDir . '/index.html');
+        $this->assertFileExists($this->outputDir . '/about/index.html');
+        $this->assertFileExists($this->outputDir . '/blog/post-1/index.html');
+
+        // Prüfen, ob der Inhalt korrekt ist
+        $this->assertEquals($responseBody, file_get_contents($this->outputDir . '/index.html'));
+    }
+
+    public function testGenerateHandlesExceptions(): void
+    {
+        // Testdaten vorbereiten
+        $routes = ['/error-page'];
+
+        // App-Mock konfigurieren, um eine Exception zu werfen
+        $this->app->method('handleRequest')->willThrowException(new \Exception('Test Exception'));
+
+        // StaticSiteGenerator initialisieren
+        $generator = new StaticSiteGenerator($this->app, $routes, $this->outputDir);
+
+        // Output-Buffer verwenden, um die Echo-Ausgaben zu erfassen
+        ob_start();
+        $generator->generate();
+        $output = ob_get_clean();
+
+        // Prüfen, ob die Fehlermeldung ausgegeben wurde
+        $this->assertStringContainsString('Fehler beim Generieren von /error-page', $output);
+
+        // Prüfen, ob keine Datei erstellt wurde
+        $this->assertFileDoesNotExist($this->outputDir . '/error-page/index.html');
+    }
+
+    public function testGetFilePathForRoute(): void
+    {
+        // StaticSiteGenerator mit Reflection für private Methoden testen
+        $generator = new StaticSiteGenerator($this->app, [], $this->outputDir);
+        $reflection = new \ReflectionClass($generator);
+        $method = $reflection->getMethod('getFilePathForRoute');
+        $method->setAccessible(true);
+
+        // Verschiedene Routentypen testen
+        $this->assertEquals(
+            $this->outputDir . '/index.html',
+            $method->invoke($generator, '/')
+        );
+
+        $this->assertEquals(
+            $this->outputDir . '/about/index.html',
+            $method->invoke($generator, '/about')
+        );
+
+        $this->assertEquals(
+            $this->outputDir . '/api/data.json',
+            $method->invoke($generator, '/api/data.json')
+        );
+    }
+}
diff --git a/tests/Unit/QrCodeTest.php b/tests/Unit/QrCodeTest.php
new file mode 100644
index 00000000..06019666
--- /dev/null
+++ b/tests/Unit/QrCodeTest.php
@@ -0,0 +1,62 @@
+<?php
+
+declare(strict_types=1);
+
+use App\Application\Service\QrCodeService;
+use App\Domain\QrCode\Exception\QrCodeException;
+use App\Domain\QrCode\QrCode;
+use App\Domain\QrCode\ValueObject\ErrorCorrectionLevel;
+use App\Domain\QrCode\ValueObject\QrCodeVersion;
+
+test('QR-Code kann mit grundlegenden Daten erstellt werden', function () {
+    $qrCode = new QrCode('Hallo Welt');
+
+    expect($qrCode->getData())->toBe('Hallo Welt');
+    expect($qrCode->getErrorCorrectionLevel())->toBe(ErrorCorrectionLevel::M);
+});
+
+test('QR-Code wirft eine Exception bei leeren Daten', function () {
+    expect(fn() => new QrCode(''))->toThrow(QrCodeException::class);
+});
+
+test('QR-Code kann als SVG generiert werden', function () {
+    $service = new QrCodeService();
+    $svg = $service->generateSvg('Test');
+
+    expect($svg)->toContain('<svg');
+    expect($svg)->toContain('</svg>');
+    expect($svg)->toContain('fill="black"');
+});
+
+test('QR-Code kann als PNG generiert werden', function () {
+    $service = new QrCodeService();
+    $png = $service->generatePng('Test');
+
+    expect($png)->toStartWith("\x89PNG");
+});
+
+test('QR-Code kann als ASCII-Art generiert werden', function () {
+    $service = new QrCodeService();
+    $ascii = $service->generateAscii('Test');
+
+    expect($ascii)->toBeString();
+    expect(strlen($ascii))->toBeGreaterThan(100);
+});
+
+test('Fehlerkorrekturlevel beeinflusst die Generierung', function () {
+    $service = new QrCodeService();
+
+    $lowMatrix = $service->generateQrCode('Test', ErrorCorrectionLevel::L);
+    $highMatrix = $service->generateQrCode('Test', ErrorCorrectionLevel::H);
+
+    expect($lowMatrix->getSize())->toBeGreaterThan(0);
+    expect($highMatrix->getSize())->toBeGreaterThan(0);
+});
+
+test('QR-Code-Version bestimmt die Größe', function () {
+    $version1 = new QrCodeVersion(1);
+    $version10 = new QrCodeVersion(10);
+
+    expect($version1->getSize())->toBe(21);
+    expect($version10->getSize())->toBe(57);
+});
diff --git a/vite.config.js b/vite.config.js
index c0eb72b7..0b5dd17d 100644
--- a/vite.config.js
+++ b/vite.config.js
@@ -1,13 +1,15 @@
 import { defineConfig } from 'vite';
 import { resolve } from 'path';
+import {VitePWA} from "vite-plugin-pwa";
+import * as fs from "node:fs";
 // Optional: TypeScript support ist ohne extra Plugin enthalten!
 // Bei Bedarf: npm install --save-dev typescript
 
 export default defineConfig({
     build: {
-        outDir: 'public',         // Output bleibt im public-Verzeichnis
+        outDir: 'dist',         // Output bleibt im public-Verzeichnis
         manifest: true,
-        emptyOutDir: false,
+        emptyOutDir: true,
         rollupOptions: {
             input: {
                 css: resolve(__dirname, 'resources/css/styles.css'),
@@ -18,5 +20,76 @@ export default defineConfig({
             plugins: []
         }
     },
-    plugins: []
+    plugins: [
+        VitePWA({
+            filename: 'sw.js',
+            registerType: 'autoUpdate',
+            includeAssets: [
+                'favicon.svg',
+                'offline.html',
+                'icons/icon-192x192.png',
+                'icons/icon-512x512.png'
+            ],
+            manifest: {
+                name: 'Meine Website',
+                short_name: 'Website',
+                start_url: '/',
+                display: 'standalone',
+                background_color: '#ffffff',
+                theme_color: '#000000',
+                icons: [
+                    {
+                        src: 'icons/icon-192x192.png',
+                        sizes: '192x192',
+                        type: 'image/png'
+                    },
+                    {
+                        src: 'icons/icon-512x512.png',
+                        sizes: '512x512',
+                        type: 'image/png'
+                    }
+                ]
+            },
+            workbox: {
+                globPatterns: ['**/*.{js,css,html,ico,png,svg}'],
+                runtimeCaching: [
+                    {
+                        urlPattern: ({ request }) => request.destination === 'document',
+                        handler: 'NetworkFirst',
+                        options: {
+                            cacheName: 'html-cache'
+                        }
+                    },
+                    {
+                        urlPattern: ({ request }) =>
+                            request.destination === 'script' || request.destination === 'style',
+                        handler: 'StaleWhileRevalidate',
+                        options: {
+                            cacheName: 'asset-cache'
+                        }
+                    },
+                    {
+                        urlPattern: ({ request }) => request.destination === 'image',
+                        handler: 'CacheFirst',
+                        options: {
+                            cacheName: 'image-cache',
+                            expiration: {
+                                maxEntries: 50,
+                                maxAgeSeconds: 60 * 60 * 24 * 30
+                            }
+                        }
+                    }
+                ],
+                navigateFallback: '/offline.html'
+            }
+        })
+    ],
+    server: {
+        https: {
+            key: fs.readFileSync('./ssl/fullchain.pem'),
+            cert: fs.readFileSync('./ssl/privkey.pem')
+        },
+        host: 'localhost',
+    //port: 3000
+    }
 });
diff --git a/worker.php b/worker.php
new file mode 100644
index 00000000..3955132a
--- /dev/null
+++ b/worker.php
@@ -0,0 +1,68 @@
+#!/usr/bin/env php
+<?php
+
+use App\Framework\CommandBus\CommandBus;
+use App\Framework\Console\ConsoleOutput;
+use App\Framework\Core\AppBootstrapper;
+use App\Framework\Queue\FileQueue;
+
+require __DIR__ . '/vendor/autoload.php';
+require __DIR__ . '/src/Framework/Debug/helpers.php';
+
+$bootstrapper = new AppBootstrapper(getcwd(), new \App\Framework\Performance\PerformanceMeter());
+$container = $bootstrapper->bootstrapWorker();
+
+$queue = new \App\Framework\Queue\RedisQueue('commands', 'redis');
+
+$worker = new \App\Framework\Worker\Worker(
+    $container,
+    $queue, #new FileQueue(__DIR__ . '/src/Framework/CommandBus/storage/queue/'),
+    $container->get(CommandBus::class),
+    $container->get(ConsoleOutput::class),
+);
+
+pcntl_signal(SIGTERM, function () use ($worker) {
+    $worker->stop();
+});
+
+pcntl_signal(SIGINT, function () use ($worker) {
+    $worker->stop();
+});
+
+$worker->start();
+
+
+
+/*
+$queue = new FileQueue(__DIR__ . '/src/Framework/CommandBus/storage/queue/');
+
+error_log('Worker started');
+
+error_log(__DIR__ . '/src/Framework/CommandBus/storage/queue');
+
+#$commandBus = $container->get(CommandBus::class);
+
+#$commandBus->dispatch(new \App\Application\Newsletter\SignUp\SignupUserToNewsletter('Michael', 'mail'));
+
+#var_dump($queue);
+
+while (true) {
+    $job = $queue->pop();
+
+    if ($job) {
+        try {
+            // Job verarbeiten
+
+            #$commandBus->handle($job);
+
+            error_log('handled: ' . $job::class);
+
+            #(new JobProcessor())->handle($job);
+        } catch (\Throwable $e) {
+            // Fehler-Handling / Retry-Logik
+        }
+    } else {
+        // Leerlauf-Pause, z.B. 100 ms
+        usleep(100_000);
+    }
+}*/
diff --git a/x_ansible/README.md b/x_ansible/README.md
new file mode 100644
index 00000000..280f6514
--- /dev/null
+++ b/x_ansible/README.md
@@ -0,0 +1,146 @@
+# Ansible-Setup für michaelschiemer.de
+
+Dieses Verzeichnis enthält die Ansible-Konfiguration für das Deployment der Website.
+
+## Verzeichnisstruktur
+
+```
+ansible/
+├── ansible.cfg         # Ansible-Konfigurationsdatei
+├── check_yaml.sh       # Skript zur Überprüfung der YAML-Syntax
+├── deploy.sh           # Deployment-Skript
+├── docker/             # Docker-Konfigurationsdateien
+├── group_vars/         # Variablen für Gruppen
+├── inventory/          # Inventar-Dateien
+│   ├── hosts.ini       # Hauptinventar
+│   ├── development     # Entwicklungsumgebung
+│   ├── staging         # Staging-Umgebung
+│   └── production      # Produktionsumgebung
+├── playbooks/          # Playbooks für verschiedene Aufgaben
+├── roles/              # Rollen für verschiedene Komponenten
+├── docker-compose.yml  # Standard-Docker-Compose-Datei
+├── setup.sh            # Setup-Skript
+└── setup.yml           # Basis-Setup-Playbook
+```
+
+## Erste Schritte
+
+Bevor Sie die Skripte verwenden können, müssen Sie diese ausführbar machen:
+
+```bash
+chmod +x ansible/setup.sh ansible/deploy.sh ansible/check_yaml.sh
+```
+
+## YAML-Syntax prüfen
+
+Bevor Sie ein Deployment starten, sollten Sie die YAML-Syntax überprüfen:
+
+```bash
+./ansible/check_yaml.sh
+```
+
+Dieses Skript findet und korrigiert die häufigsten YAML-Syntaxprobleme.
+
+## Verwendung
+
+### Einfache Verwendung mit dem Setup-Skript
+
+```bash
+# Server-Setup durchführen
+./ansible/setup.sh setup staging
+
+# Deployment durchführen
+./ansible/setup.sh deploy staging
+```
+
+### Deployment mit dem einfachen Deploy-Skript
+
+```bash
+# Deployment für die Staging-Umgebung
+./ansible/deploy.sh staging
+
+# Deployment für die Produktionsumgebung
+./ansible/deploy.sh production
+```
+
+### Manuelle Verwendung
+
+```bash
+# Wechsle ins Ansible-Verzeichnis
+cd ansible
+
+# Server-Setup durchführen
+ansible-playbook -i inventory/hosts.ini setup.yml --limit staging
+
+# Deployment durchführen
+ansible-playbook -i inventory/hosts.ini playbooks/deploy.yml --limit staging
+```
+
+### Mit Tags
+
+```bash
+# Nur bestimmte Teile ausführen
+ansible-playbook -i inventory/hosts.ini playbooks/deploy.yml --limit staging --tags="deploy,check"
+```
+
+## Umgebungsvariablen
+
+Die Konfiguration für die verschiedenen Umgebungen wird in den entsprechenden Dateien unter `group_vars/` definiert:
+
+- `all.yml`: Variablen für alle Umgebungen
+- `common.yml`: Gemeinsame Variablen
+- `staging.yml`: Variablen für die Staging-Umgebung
+- `production.yml`: Variablen für die Produktionsumgebung
+
+Folgende Hauptvariablen werden verwendet:
+
+- `deploy_root`: Zielverzeichnis für das Deployment (/var/www/michaelschiemer)
+- `app_domain`: Domain für die Anwendung
+- `deploy_user`: Benutzer für das Deployment (deploy)
+
+## Fehlerbehandlung
+
+Wenn Sie auf Fehler stoßen, prüfen Sie folgende Punkte:
+
+1. **YAML-Syntax-Fehler**: 
+   - Führen Sie `./ansible/check_yaml.sh` aus, um Probleme zu identifizieren
+   - Stellen Sie sicher, dass jede YAML-Datei nur ein Dokument enthält (nur ein `---` am Anfang)
+   - Achten Sie auf korrekte Einrückung und Leerzeichen
+
+2. **Berechtigungen**:
+   - Stellen Sie sicher, dass die Scripts ausführbar sind: `chmod +x ansible/*.sh`
+   - Überprüfen Sie, ob der Benutzer die nötigen Berechtigungen auf dem Server hat
+
+3. **Arbeitsverzeichnis**:
+   - Führen Sie die Skripte vom Hauptverzeichnis des Projekts aus: `./ansible/deploy.sh`
+   - Bei manueller Ausführung: Wechseln Sie ins Ansible-Verzeichnis
+
+4. **SSH-Schlüssel**:
+   - Prüfen Sie, ob der SSH-Schlüssel für den Zugriff auf den Server korrekt eingerichtet ist
+   - Testen Sie die SSH-Verbindung manuell: `ssh deploy@94.16.110.151`
+
+5. **Abhängigkeiten**:
+   - Stellen Sie sicher, dass Ansible installiert ist: `ansible --version`
+   - Bei Bedarf: `pip install ansible`
+
+## Troubleshooting häufiger Fehler
+
+### "We were unable to read either as JSON nor YAML"
+
+Dieser Fehler tritt auf, wenn mehrere YAML-Dokumente in einer Datei vorhanden sind. Lösung:
+
+1. Führen Sie `./ansible/check_yaml.sh` aus, um problematische Dateien zu identifizieren
+2. Entfernen Sie alle `---` außer dem ersten in jeder Datei
+3. Stellen Sie sicher, dass keine leeren Zeilen vor dem ersten `---` stehen
+
+### "No hosts matched"
+
+Dieser Fehler tritt auf, wenn die Host-Gruppe nicht im Inventory gefunden wurde:
+
+1. Überprüfen Sie die Datei `inventory/hosts.ini`
+2. Stellen Sie sicher, dass die angegebene Gruppe existiert
+3. Überprüfen Sie die `--limit` Option und den Host-Namen
+
+## Weitere Informationen
+
+Diese Konfiguration verwendet Docker und Docker Compose für die Containerisierung der Anwendung. Die Deployment-Strategie basiert auf der Synchronisierung von Dateien vom Entwicklungsrechner zum Zielserver und dem Starten der Container über Docker Compose.
diff --git a/x_ansible/ansible.cfg b/x_ansible/ansible.cfg
new file mode 100644
index 00000000..b0f280eb
--- /dev/null
+++ b/x_ansible/ansible.cfg
@@ -0,0 +1,34 @@
+[defaults]
+inventory = inventory/hosts.ini
+host_key_checking = False
+remote_user = deploy
+roles_path = roles
+allow_world_readable_tmpfiles = True
+
+[privilege_escalation]
+become = True
+become_method = sudo
+become_user = root
+become_ask_pass = False
+
+[ssh_connection]
+ssh_args = -o ControlMaster=auto -o ControlPersist=60s -o ForwardAgent=yes
+pipelining = True
+[defaults]
+inventory = inventory/hosts.ini
+host_key_checking = False
+deprecation_warnings = False
+command_warnings = False
+interpreter_python = auto_silent
+force_color = True
+
+[ssh_connection]
+ssh_args = -o ControlMaster=auto -o ControlPersist=60s -o StrictHostKeyChecking=no
+pipelining = True
+transfer_method = smart
+
+[privilege_escalation]
+become = True
+become_method = sudo
+become_user = root
+become_ask_pass = False
diff --git a/x_ansible/check_yaml.sh b/x_ansible/check_yaml.sh
new file mode 100755
index 00000000..a39353d5
--- /dev/null
+++ b/x_ansible/check_yaml.sh
@@ -0,0 +1,75 @@
+#!/bin/bash
+
+# Skript zur Überprüfung der YAML-Syntax in Ansible-Dateien
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+
+# Farbdefinitionen
+GREEN="\033[0;32m"
+YELLOW="\033[1;33m"
+RED="\033[0;31m"
+NC="\033[0m" # No Color
+
+echo -e "${GREEN}=== Überprüfe YAML-Syntax in Ansible-Dateien ===${NC}\n"
+
+# Fehler-Zähler
+errors=0
+
+# Prüfe alle .yml-Dateien im Ansible-Verzeichnis
+find "$SCRIPT_DIR" -name "*.yml" | sort | while read -r file; do
+    # Überspringe bestimmte Verzeichnisse
+    if [[ "$file" == *"/templates/"* ]]; then
+        continue
+    fi
+
+    echo -e "Prüfe: ${YELLOW}$(basename "$file")${NC} (${file})"
+
+    # Prüfe ob die Datei leer ist
+    if [ ! -s "$file" ]; then
+        echo -e "  ${YELLOW}Warnung: Datei ist leer${NC}"
+        continue
+    fi
+
+    # Überprüfung mit ansible-playbook syntax-check
+    if grep -q "^---" "$file"; then
+        ansible-playbook --syntax-check "$file" &>/dev/null
+        if [ $? -ne 0 ]; then
+            echo -e "  ${RED}Fehler: Syntax-Fehler in der Datei${NC}"
+            echo -e "  Detaillierte Prüfung:"
+            ansible-playbook --syntax-check "$file"
+            errors=$((errors+1))
+            continue
+        fi
+    fi
+
+    # Überprüfung mit yamllint
+    if command -v yamllint &>/dev/null; then
+        yamllint -d relaxed "$file" &>/dev/null
+        if [ $? -ne 0 ]; then
+            echo -e "  ${YELLOW}Warnung: yamllint hat Probleme gefunden${NC}"
+            yamllint -d relaxed "$file"
+        fi
+    fi
+
+    # Überprüfung auf mehrere YAML-Dokumente
+    doc_count=$(grep -c "^---" "$file")
+    if [ "$doc_count" -gt 1 ]; then
+        echo -e "  ${RED}Fehler: Mehrere YAML-Dokumente in einer Datei (${doc_count} Dokumente)${NC}"
+        echo -e "  Betroffene Zeilen:"
+        grep -n "^---" "$file"
+        errors=$((errors+1))
+    fi
+
+    # Wenn alles ok ist
+    if [ "$errors" -eq 0 ]; then
+        echo -e "  ${GREEN}✓ OK${NC}"
+    fi
+done
+
+if [ "$errors" -gt 0 ]; then
+    echo -e "\n${RED}Fehler gefunden! $errors Dateien haben Probleme.${NC}"
+    echo -e "Bitte korrigieren Sie die YAML-Syntax-Fehler, bevor Sie fortfahren."
+    exit 1
+else
+    echo -e "\n${GREEN}Alle YAML-Dateien haben die Syntax-Prüfung bestanden!${NC}"
+    exit 0
+fi
diff --git a/ansible/client-configs/michael.conf b/x_ansible/client-configs/michael.conf
similarity index 100%
rename from ansible/client-configs/michael.conf
rename to x_ansible/client-configs/michael.conf
diff --git a/x_ansible/deploy.sh b/x_ansible/deploy.sh
new file mode 100755
index 00000000..4e02f9d7
--- /dev/null
+++ b/x_ansible/deploy.sh
@@ -0,0 +1,19 @@
+#!/bin/bash
+
+# Einfaches Deployment-Script für michaelschiemer.de
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+
+# Standardumgebung ist staging
+ENVIRONMENT=${1:-staging}
+
+echo "=== Deployment für $ENVIRONMENT-Umgebung ==="
+
+# Führe Deployment aus
+cd "$SCRIPT_DIR"
+ansible-playbook -i "$SCRIPT_DIR/inventory/hosts.ini" "$SCRIPT_DIR/playbooks/deploy.yml" --limit $ENVIRONMENT -v
+
+if [ $? -eq 0 ]; then
+    echo "\n✅ Deployment erfolgreich abgeschlossen!"
+else
+    echo "\n❌ Deployment fehlgeschlagen!"
+fi
diff --git a/x_ansible/docker-compose.yml b/x_ansible/docker-compose.yml
new file mode 100644
index 00000000..e11e8283
--- /dev/null
+++ b/x_ansible/docker-compose.yml
@@ -0,0 +1,74 @@
+version: '3.8'
+version: '3.8'
+
+services:
+  php:
+    build:
+      context: ./docker/php
+      dockerfile: Dockerfile-simple
+    volumes:
+      - ./src:/var/www/html/src:rw
+      - ./public:/var/www/html/public:rw
+    networks:
+      - backend
+
+  nginx:
+    image: nginx:alpine
+    ports:
+      - "80:80"
+      - "443:443"
+    volumes:
+      - ./public:/var/www/html/public:ro
+      - ./docker/nginx/nginx.conf:/etc/nginx/nginx.conf:ro
+      - ./docker/nginx/default.conf:/etc/nginx/conf.d/default.conf:ro
+    depends_on:
+      - php
+    networks:
+      - frontend
+      - backend
+
+  redis:
+    image: redis:alpine
+    networks:
+      - cache
+
+networks:
+  frontend:
+  backend:
+  cache:
+services:
+  php:
+    build:
+      context: ./docker/php
+      dockerfile: Dockerfile
+    volumes:
+      - ${DEPLOY_ROOT:-/var/www/michaelschiemer}/src:/var/www/html/src:rw
+      - ${DEPLOY_ROOT:-/var/www/michaelschiemer}/public:/var/www/html/public:rw
+    networks:
+      - backend
+
+  nginx:
+    build:
+      context: ./docker/nginx
+      dockerfile: Dockerfile
+    ports:
+      - "80:80"
+      - "443:443"
+    volumes:
+      - ${DEPLOY_ROOT:-/var/www/michaelschiemer}/public:/var/www/html/public:ro
+      - ${DEPLOY_ROOT:-/var/www/michaelschiemer}/ssl:/etc/nginx/ssl:ro
+    depends_on:
+      - php
+    networks:
+      - frontend
+      - backend
+
+  redis:
+    image: redis:alpine
+    networks:
+      - cache
+
+networks:
+  frontend:
+  backend:
+  cache:
diff --git a/x_ansible/docker/nginx/Dockerfile b/x_ansible/docker/nginx/Dockerfile
new file mode 100644
index 00000000..6a2004a9
--- /dev/null
+++ b/x_ansible/docker/nginx/Dockerfile
@@ -0,0 +1,11 @@
+FROM nginx:alpine
+
+# Standardkonfigurationen kopieren
+COPY nginx.conf /etc/nginx/nginx.conf
+COPY default.conf /etc/nginx/conf.d/default.conf
+
+# Erstelle Verzeichnis für SSL-Zertifikate
+RUN mkdir -p /etc/nginx/ssl
+
+# Starte Nginx im Vordergrund
+CMD ["nginx", "-g", "daemon off;"]
diff --git a/x_ansible/docker/nginx/default.conf b/x_ansible/docker/nginx/default.conf
new file mode 100644
index 00000000..af775b99
--- /dev/null
+++ b/x_ansible/docker/nginx/default.conf
@@ -0,0 +1,65 @@
+server {
+    listen 80;
+    listen [::]:80;
+    server_name _;
+    root /var/www/html/public;
+    index index.php index.html;
+
+    location / {
+        try_files $uri $uri/ /index.php?$query_string;
+    }
+
+    location ~ \.php$ {
+        fastcgi_pass php:9000;
+        fastcgi_index index.php;
+        fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
+        include fastcgi_params;
+    }
+}
+
+# HTTPS Server
+server {
+    listen 443 ssl;
+    listen [::]:443 ssl;
+    server_name _;
+
+    ssl_certificate     /etc/nginx/ssl/fullchain.pem;
+    ssl_certificate_key /etc/nginx/ssl/privkey.pem;
+    ssl_protocols       TLSv1.2 TLSv1.3;
+    ssl_ciphers         HIGH:!aNULL:!MD5;
+
+    root /var/www/html/public;
+    index index.php index.html;
+server {
+    listen 80;
+    server_name localhost;
+    root /var/www/html/public;
+
+    index index.php index.html;
+
+    location / {
+        try_files $uri $uri/ /index.php?$query_string;
+    }
+
+    location ~ \.php$ {
+        fastcgi_pass php:9000;
+        fastcgi_index index.php;
+        fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
+        include fastcgi_params;
+    }
+
+    location ~ /\.ht {
+        deny all;
+    }
+}
+    location / {
+        try_files $uri $uri/ /index.php?$query_string;
+    }
+
+    location ~ \.php$ {
+        fastcgi_pass php:9000;
+        fastcgi_index index.php;
+        fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
+        include fastcgi_params;
+    }
+}
diff --git a/x_ansible/docker/nginx/nginx.conf b/x_ansible/docker/nginx/nginx.conf
new file mode 100644
index 00000000..b63ad39b
--- /dev/null
+++ b/x_ansible/docker/nginx/nginx.conf
@@ -0,0 +1,53 @@
+user  nginx;
+worker_processes  auto;
+
+error_log  /var/log/nginx/error.log warn;
+pid        /var/run/nginx.pid;
+
+events {
+    worker_connections  1024;
+}
+
+http {
+    include       /etc/nginx/mime.types;
+    default_type  application/octet-stream;
+
+    log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
+                      '$status $body_bytes_sent "$http_referer" '
+                      '"$http_user_agent" "$http_x_forwarded_for"';
+user  nginx;
+worker_processes  auto;
+
+error_log  /var/log/nginx/error.log warn;
+pid        /var/run/nginx.pid;
+
+events {
+    worker_connections  1024;
+}
+
+http {
+    include       /etc/nginx/mime.types;
+    default_type  application/octet-stream;
+
+    log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
+                      '$status $body_bytes_sent "$http_referer" '
+                      '"$http_user_agent" "$http_x_forwarded_for"';
+
+    access_log  /var/log/nginx/access.log  main;
+
+    sendfile        on;
+    #tcp_nopush     on;
+
+    keepalive_timeout  65;
+
+    #gzip  on;
+
+    include /etc/nginx/conf.d/*.conf;
+}
+    access_log  /var/log/nginx/access.log  main;
+
+    sendfile        on;
+    keepalive_timeout  65;
+
+    include /etc/nginx/conf.d/*.conf;
+}
diff --git a/x_ansible/docker/php/Dockerfile b/x_ansible/docker/php/Dockerfile
new file mode 100644
index 00000000..ddbaea0a
--- /dev/null
+++ b/x_ansible/docker/php/Dockerfile
@@ -0,0 +1,16 @@
+FROM php:8.4-fpm
+
+RUN apt-get update && apt-get install -y \
+    git \
+    unzip \
+    libzip-dev \
+    zip \
+    && docker-php-ext-install zip pdo pdo_mysql \
+    && docker-php-ext-install opcache \
+    && docker-php-ext-install pcntl posix shmop \
+    && apt-get clean \
+    && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /var/www/html
+
+CMD ["php-fpm"]
diff --git a/x_ansible/docker/php/Dockerfile-simple b/x_ansible/docker/php/Dockerfile-simple
new file mode 100644
index 00000000..90a60ec9
--- /dev/null
+++ b/x_ansible/docker/php/Dockerfile-simple
@@ -0,0 +1,15 @@
+FROM php:8.1-fpm
+
+RUN apt-get update && apt-get install -y \
+    git \
+    unzip \
+    libzip-dev \
+    zip \
+    && docker-php-ext-install zip pdo pdo_mysql \
+    && docker-php-ext-install opcache \
+    && apt-get clean \
+    && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /var/www/html
+
+CMD ["php-fpm"]
diff --git a/x_ansible/group_vars/all.yml b/x_ansible/group_vars/all.yml
new file mode 100644
index 00000000..82d6afd1
--- /dev/null
+++ b/x_ansible/group_vars/all.yml
@@ -0,0 +1,91 @@
+# Basis-Konfiguration
+app_name: michaelschiemer
+app_domain: test.michaelschiemer.de
+app_email: kontakt@michaelschiemer.de
+
+# Verzeichnisse
+project_root: "{{ playbook_dir | dirname }}"
+app_root: /var/www/{{ app_name }}
+app_public: "{{ app_root }}/public"
+
+# Docker
+docker_version: "20.10"
+docker_compose_version: "2.24.5"
+
+# Benutzer
+deploy_user: deploy
+
+# Let's Encrypt
+letsencrypt_enabled: true
+letsencrypt_certbot_method: webroot  # oder standalone oder nginx
+
+
+#netcup_customer_id: "218722"
+#netcup_api_key: "dmJINUMyNjRmOG1aNDViajZHN2JkOTFRUjU3ckE5ZjJ1Zm1vUz"
+#netcup_api_password: "iGWL8Hl4m93DgESsP/MPXmtDd0hEVkZ3480Na0psTlXRALnopl"
+#netcup_vserver_id: "v2202309206672239295"
+
+
+# fallback_ip:
+
+wg_all_clients_private_keys:
+  michael: "PITbFZ3UfY5vD5dYUCELO37Qo2W8I4R8+r6D9CeMrm4="
+---
+# Allgemeine Variablen für alle Hosts
+---
+# Globale Variablen für alle Umgebungen
+
+# Docker-Konfiguration
+docker_compose_version: "1.29.2"
+
+# Nginx-Konfiguration
+nginx_worker_processes: auto
+nginx_worker_connections: 1024
+
+# Verwendeter PHP-Container
+php_version: "8.1"
+
+# Allgemeine Anwendungsvariablen
+app_name: "michaelschiemer"
+app_env: "production"
+# Docker-Einstellungen
+docker_version: "20.10"
+docker_compose_version: "2.24.5"
+docker_install_compose: true
+docker_user: "{{ ansible_user | default('deploy') }}"
+
+# Deployment-Verzeichnisse
+deploy_root: /var/www/michaelschiemer
+deploy_public: "{{ deploy_root }}/public"
+docker_compose_project_path: "{{ deploy_root }}"
+
+# Anwendungsvariablen
+project_root: "{{ playbook_dir }}/../.."
+project_source: "{{ playbook_dir }}/../.."
+app_domain: "{{ hostvars[inventory_hostname]['ansible_host'] | default(inventory_hostname) }}"
+---
+# Variablen für alle Gruppen
+
+# Standardwerte für Deployment
+deploy_root: /var/www/michaelschiemer
+deploy_public: "{{ deploy_root }}/public"
+deploy_user: "{{ ansible_user | default('deploy') }}"
+
+# Projektpfade
+project_source: "{{ playbook_dir }}/../.."
+project_root: "{{ playbook_dir }}/../.."
+
+# Docker-Konfiguration
+docker_compose_project_path: "{{ deploy_root }}"
+
+# Standard-Domain (wird normalerweise durch umgebungsspezifische Variablen überschrieben)
+app_domain: "localhost"
+
+# Standard Nginx-Konfiguration
+nginx_worker_processes: "auto"
+nginx_worker_connections: 1024
+
+wireguard_clients:
+  - name: michael
+    address: 10.8.0.2
+    public_key: DEIN_PUBLIC_KEY
diff --git a/x_ansible/group_vars/common.yml b/x_ansible/group_vars/common.yml
new file mode 100644
index 00000000..57820cb8
--- /dev/null
+++ b/x_ansible/group_vars/common.yml
@@ -0,0 +1,15 @@
+---
+# Gemeinsame Variablen für alle Umgebungen
+
+# Deployment-Variablen
+deploy_root: /var/www/michaelschiemer
+deploy_public: "{{ deploy_root }}/public"
+deploy_user: deploy
+
+# Anwendungsvariablen
+app_domain: "{{ hostvars[inventory_hostname]['ansible_host'] | default(inventory_hostname) }}"
+project_source: "{{ playbook_dir }}/../.."
+project_root: "{{ playbook_dir }}/../.."
+
+# Docker-Compose-Pfad
+docker_compose_project_path: "{{ deploy_root }}"
diff --git a/x_ansible/group_vars/localhost.yml b/x_ansible/group_vars/localhost.yml
new file mode 100644
index 00000000..311c45ad
--- /dev/null
+++ b/x_ansible/group_vars/localhost.yml
@@ -0,0 +1,25 @@
+nginx_vite_proxy_include: "vite-proxy.inc.dev"
+# Localhost-spezifische Konfiguration
+
+# Deployment-Pfade
+deploy_root: /home/michael/dev/michaelschiemer
+docker_compose_project_path: "{{ deploy_root }}"
+env_file_path: "{{ deploy_root }}/.env"
+deploy_public: "{{ deploy_root }}/public"
+
+# Domainname für lokale Entwicklung
+app_domain: "localhost"
+
+# Umgebungsvariablen
+env_vars:
+  APP_ENV: development
+  APP_DEBUG: "true"
+  APP_PORT: 80
+  APP_SSL_PORT: 443
+
+# Docker-Compose-Projekt
+compose_project_name: "michaelschiemer_dev"
+
+# Lokale Quell- und Zielverzeichnisse sind identisch
+project_source: "{{ deploy_root }}"
+project_root: "{{ deploy_root }}"
\ No newline at end of file
diff --git a/x_ansible/group_vars/production.yml b/x_ansible/group_vars/production.yml
new file mode 100644
index 00000000..c5b65444
--- /dev/null
+++ b/x_ansible/group_vars/production.yml
@@ -0,0 +1,37 @@
+---
+# Produktions-spezifische Variablen
+environment: production
+
+# Deployment-Pfade
+deploy_root: /var/www/michaelschiemer
+docker_compose_project_path: "{{ deploy_root }}"
+env_file_path: "{{ deploy_root }}/.env"
+deploy_public: "{{ deploy_root }}/public"
+
+# Domainname für Produktion
+app_domain: "michaelschiemer.de"
+app_env: "production"
+
+# Umgebungsvariablen
+env_vars:
+  APP_ENV: production
+  APP_DEBUG: "false"
+  APP_PORT: 80
+  APP_SSL_PORT: 443
+  COMPOSER_INSTALL_FLAGS: --no-dev --optimize-autoloader
+
+# Docker-Compose-Projekt
+compose_project_name: "michaelschiemer_prod"
+
+# SSL-Konfiguration
+ssl_enabled: true
+ssl_cert_path: "/etc/letsencrypt/live/{{ app_domain }}"
+
+# Performance-Optimierung
+redis_maxmemory: "512mb"
+nginx_worker_processes: "auto"
+nginx_worker_connections: 2048
+
+# Cache-Einstellungen
+cache_enabled: true
+cache_lifetime: 3600
diff --git a/x_ansible/group_vars/staging.yml b/x_ansible/group_vars/staging.yml
new file mode 100644
index 00000000..ba0709c4
--- /dev/null
+++ b/x_ansible/group_vars/staging.yml
@@ -0,0 +1,34 @@
+---
+# Staging-spezifische Variablen
+environment: staging
+
+# Deployment-Pfade
+deploy_root: /var/www/stage.michaelschiemer
+docker_compose_project_path: "{{ deploy_root }}"
+env_file_path: "{{ deploy_root }}/.env"
+deploy_public: "{{ deploy_root }}/public"
+
+# Domainname für Staging
+app_domain: "staging.michaelschiemer.de"
+app_env: "staging"
+
+# Nginx-Konfiguration
+nginx_vite_proxy_include: "vite-proxy.inc.prod"
+
+# Umgebungsvariablen
+env_vars:
+  APP_ENV: staging
+  APP_DEBUG: "false"
+  APP_PORT: 80
+  APP_SSL_PORT: 443
+
+# Docker-Compose-Projekt
+compose_project_name: "michaelschiemer_staging"
+
+# Zusätzliche Staging-spezifische Einstellungen
+database_host: "db"
+database_name: "michaelschiemer_staging"
+database_user: "michaelschiemer"
+
+# Quelle der Anwendung (lokales Entwicklungsverzeichnis)
+project_source: "/home/michael/dev/michaelschiemer"
diff --git a/ansible/group_vars/vpn.yml b/x_ansible/group_vars/vpn.yml
similarity index 100%
rename from ansible/group_vars/vpn.yml
rename to x_ansible/group_vars/vpn.yml
diff --git a/ansible/roles/nginx/templates/default.conf.j2 b/x_ansible/group_vars/web.yml
similarity index 100%
rename from ansible/roles/nginx/templates/default.conf.j2
rename to x_ansible/group_vars/web.yml
diff --git a/x_ansible/inventory/development b/x_ansible/inventory/development
new file mode 100644
index 00000000..a433c147
--- /dev/null
+++ b/x_ansible/inventory/development
@@ -0,0 +1,8 @@
+# Entwicklungsumgebung (lokal)
+[localhost]
+127.0.0.1 ansible_connection=local
+
+# Variablen für die Entwicklungsumgebung
+[localhost:vars]
+ansible_python_interpreter=/usr/bin/python3
+environment=development
diff --git a/x_ansible/inventory/hosts.ini b/x_ansible/inventory/hosts.ini
new file mode 100644
index 00000000..2aa32222
--- /dev/null
+++ b/x_ansible/inventory/hosts.ini
@@ -0,0 +1,56 @@
+[localhost]
+127.0.0.1 ansible_connection=local
+[localhost]
+127.0.0.1 ansible_connection=local
+
+[staging]
+94.16.110.151 ansible_user=deploy ansible_ssh_private_key_file=/home/michael/.ssh/staging
+
+[production]
+# Hier Produktionsserver eintragen
+# beispiel.com ansible_user=deploy ansible_ssh_private_key_file=~/.ssh/production
+
+[development]
+127.0.0.1 ansible_connection=local
+
+[web:children]
+staging
+production
+
+[all:vars]
+ansible_python_interpreter=/usr/bin/python3
+[staging]
+94.16.110.151 ansible_user=deploy ansible_ssh_private_key_file=~/.ssh/staging
+
+[production]
+# Hier Produktionsserver eintragen
+# beispiel.com ansible_user=deploy ansible_ssh_private_key_file=~/.ssh/production
+
+[vpn]
+94.16.110.151 ansible_user=deploy
+
+[web:children]
+staging
+production
+[localhost]
+127.0.0.1 ansible_connection=local
+
+[staging]
+94.16.110.151 ansible_user=deploy ansible_ssh_private_key_file=~/.ssh/staging
+
+[production]
+# Hier Produktionsserver eintragen
+# beispiel.com ansible_user=deploy ansible_ssh_private_key_file=~/.ssh/production
+
+[web:children]
+staging
+production
+
+[web:vars]
+ansible_python_interpreter=/usr/bin/python3
+deploy_root=/var/www/michaelschiemer
+deploy_user=deploy
+[web:vars]
+ansible_python_interpreter=/usr/bin/python3
+deploy_root=/var/www/michaelschiemer
+deploy_user=deploy
diff --git a/x_ansible/inventory/production b/x_ansible/inventory/production
new file mode 100644
index 00000000..e7238f32
--- /dev/null
+++ b/x_ansible/inventory/production
@@ -0,0 +1,9 @@
+# Produktionsserver
+[production]
+# Hier Produktionsserver eintragen
+# beispiel.com ansible_user=deploy ansible_ssh_private_key_file=~/.ssh/production
+
+# Variablen für die Produktionsumgebung
+[production:vars]
+ansible_python_interpreter=/usr/bin/python3
+environment=production
diff --git a/x_ansible/inventory/staging b/x_ansible/inventory/staging
new file mode 100644
index 00000000..bc83d908
--- /dev/null
+++ b/x_ansible/inventory/staging
@@ -0,0 +1,8 @@
+# Staging-Server
+[staging]
+94.16.110.151 ansible_user=deploy ansible_ssh_private_key_file=/home/michael/.ssh/staging
+
+# Variablen für die Staging-Umgebung
+[staging:vars]
+ansible_python_interpreter=/usr/bin/python3
+environment=staging
diff --git a/ansible/playbooks/check.yml b/x_ansible/playbooks/check.yml
similarity index 100%
rename from ansible/playbooks/check.yml
rename to x_ansible/playbooks/check.yml
diff --git a/x_ansible/playbooks/deploy.yml b/x_ansible/playbooks/deploy.yml
new file mode 100644
index 00000000..9e18e858
--- /dev/null
+++ b/x_ansible/playbooks/deploy.yml
@@ -0,0 +1,92 @@
+---
+- name: Deployment in jeweilige Umgebung
+  hosts: web
+  become: true
+  gather_facts: true
+
+  vars:
+    project_source: "{{ playbook_dir }}/../.."
+    docker_compose_project_path: "{{ deploy_root }}"
+
+  pre_tasks:
+    - name: Überprüfe Server-Verbindung
+      ping:
+      tags: [always, check]
+
+    - name: Zeige Server-Informationen
+      debug:
+        msg: "Verbunden mit {{ inventory_hostname }} ({{ ansible_host | default('IP unbekannt') }})"
+      tags: [always, check]
+
+  roles:
+    - common
+    - docker
+    - nginx
+
+  tasks:
+    - name: Stelle sicher, dass Zielverzeichnisse existieren
+      file:
+        path: "{{ item }}"
+        state: directory
+        owner: "{{ deploy_user }}"
+        group: "{{ deploy_user }}"
+        mode: '0755'
+      loop:
+        - "{{ deploy_root }}"
+        - "{{ deploy_root }}/public"
+        - "{{ deploy_root }}/ssl"
+        - "{{ deploy_root }}/src"
+        - "{{ deploy_root }}/docker"
+        - "{{ deploy_root }}/docker/nginx"
+        - "{{ deploy_root }}/docker/php"
+      tags: [deploy, folders]
+
+    - name: Kopiere Docker-Konfigurationen
+      copy:
+        src: "{{ playbook_dir }}/../docker/"
+        dest: "{{ deploy_root }}/docker/"
+        mode: '0644'
+        owner: "{{ deploy_user }}"
+        group: "{{ deploy_user }}"
+      tags: [deploy, docker]
+
+    - name: Kopiere docker-compose.yml
+      copy:
+        src: "{{ playbook_dir }}/../docker-compose.yml"
+        dest: "{{ deploy_root }}/docker-compose.yml"
+        mode: '0644'
+        owner: "{{ deploy_user }}"
+        group: "{{ deploy_user }}"
+      tags: [deploy, docker]
+
+    - name: Container starten oder neustarten
+      ansible.builtin.shell: |
+        cd "{{ deploy_root }}" && \
+        docker-compose -f docker-compose.yml -p michaelschiemer up -d --build
+      tags: [deploy, docker]
+
+  post_tasks:
+    - name: Überprüfe Anwendungsstatus
+      uri:
+        url: "http://{{ ansible_host }}/"
+        return_content: no
+        status_code: 200, 301, 302, 403, 404
+        validate_certs: no
+        timeout: 10
+      register: app_status
+      ignore_errors: yes
+      delegate_to: localhost
+      become: no
+      tags: [check]
+
+    - name: Zeige Deployment-Ergebnis
+      debug:
+        msg: |
+          Deployment abgeschlossen:
+          - Server: {{ inventory_hostname }}
+          - Umgebung: {{ environment | default('unbekannt') }}
+          - Status: {% if app_status.status is defined and app_status.status == 200 %}Erfolgreich (HTTP 200){% else %}Überprüfung erforderlich{% endif %}
+
+          Anwendung sollte erreichbar sein unter: http://{{ ansible_host }}/
+      tags: [check]
+
diff --git a/x_ansible/playbooks/deploy/dev.yml b/x_ansible/playbooks/deploy/dev.yml
new file mode 100644
index 00000000..9b9c3fb2
--- /dev/null
+++ b/x_ansible/playbooks/deploy/dev.yml
@@ -0,0 +1,40 @@
+- name: Deployment für DEV (localhost)
+  hosts: localhost
+  become: true
+  gather_facts: false
+
+  vars:
+    docker_compose_project_path: "/home/michael/dev/michaelschiemer"
+    env_file_path: "/var/www/michaelschiemer/.env"
+    deploy_root: /var/www/michaelschiemer
+    deploy_public: "{{ deploy_root }}/public"
+    deploy_user: deploy
+    app_domain: "localhost"           # Passe ggf. an
+    project_root: "/home/michael/dev/michaelschiemer"
+
+  # Rollen definieren, die für dieses Deployment benötigt werden
+  roles:
+    - common
+    - nginx
+    - php
+    - redis
+
+  # Vorbereitung für das Deployment
+  pre_tasks:
+    - name: Prüfe Voraussetzungen
+      debug:
+        msg: "Starte Deployment für Entwicklungsumgebung auf {{ docker_compose_project_path }}"
+      tags: [always]
+
+  # Haupttasks für das Deployment
+  tasks:
+    - name: Deployment durchführen
+      import_tasks: ../deploy/includes/deploy_common.yml
+      tags: [deploy]
+
+  # Nachbereitung nach dem Deployment
+  post_tasks:
+    - name: Deployment abgeschlossen
+      debug:
+        msg: "Deployment auf {{ docker_compose_project_path }} erfolgreich abgeschlossen"
+      tags: [always]
diff --git a/x_ansible/playbooks/deploy/includes/docker_compose.yml b/x_ansible/playbooks/deploy/includes/docker_compose.yml
new file mode 100644
index 00000000..37cf2d72
--- /dev/null
+++ b/x_ansible/playbooks/deploy/includes/docker_compose.yml
@@ -0,0 +1,67 @@
+---
+# Datei: ansible/playbooks/deploy/includes/docker_compose.yml
+# Verwaltet die Docker-Compose-Konfiguration und -Ausführung
+
+- name: Erstelle Docker-Compose-Datei
+  copy:
+    dest: "{{ docker_compose_project_path }}/docker-compose-simple.yml"
+    content: |
+      version: '3.8'
+
+      services:
+        php:
+          container_name: michaelschiemer_php
+          build:
+            context: ./docker/php
+            dockerfile: Dockerfile-simple
+          volumes:
+            - ./src:/var/www/html/src:rw
+            - ./public:/var/www/html/public:rw
+          networks:
+            - backend
+
+        nginx:
+          container_name: michaelschiemer_nginx
+          image: nginx:alpine
+          ports:
+            - "80:80"
+            - "443:443"
+          volumes:
+            - ./public:/var/www/html/public:ro
+            - ./docker/nginx/nginx.conf:/etc/nginx/nginx.conf:ro
+            - ./docker/nginx/default.conf:/etc/nginx/conf.d/default.conf:ro
+          depends_on:
+            - php
+          networks:
+            - frontend
+            - backend
+
+        redis:
+          container_name: michaelschiemer_redis
+          image: redis:alpine
+          volumes:
+            - ./docker/redis/redis.conf:/usr/local/etc/redis/redis.conf:ro
+          command: ["redis-server", "/usr/local/etc/redis/redis.conf"]
+          networks:
+            - cache
+
+      networks:
+        frontend:
+        backend:
+        cache:
+    owner: root
+    group: root
+    mode: '0644'
+
+- name: Erstelle .env-Datei falls nicht vorhanden
+  copy:
+    dest: "{{ docker_compose_project_path }}/.env"
+    content: |
+      COMPOSE_PROJECT_NAME=michaelschiemer
+      APP_ENV=production
+      APP_PORT=80
+      APP_SSL_PORT=443
+    owner: root
+    group: root
+    mode: '0644'
+  when: not lookup('vars', 'project_root', default=false)
diff --git a/x_ansible/playbooks/deploy/includes/docker_run.yml b/x_ansible/playbooks/deploy/includes/docker_run.yml
new file mode 100644
index 00000000..5f733fe8
--- /dev/null
+++ b/x_ansible/playbooks/deploy/includes/docker_run.yml
@@ -0,0 +1,57 @@
+---
+# Datei: ansible/playbooks/deploy/includes/docker_run.yml
+# Verwaltet das Starten und Überwachen der Docker-Container
+
+# Sicherstellen, dass vor dem Neustart alle Container gestoppt werden
+- name: Container stoppen, falls bereits laufend
+  ansible.builtin.shell: |
+    docker-compose -p michaelschiemer -f "{{ docker_compose_project_path | regex_replace('//$', '/') }}docker-compose-simple.yml" down --remove-orphans || true
+  args:
+    chdir: "{{ docker_compose_project_path | regex_replace('//$', '/') }}"
+    executable: /bin/bash
+  environment:
+    COMPOSE_IGNORE_ORPHANS: "True"
+  ignore_errors: yes
+
+# Container neustarten mit der vereinfachten Konfiguration
+- name: Docker Container starten
+  ansible.builtin.shell: |
+    export DOCKER_BUILDKIT=0
+    docker-compose -p michaelschiemer -f "{{ docker_compose_project_path | regex_replace('//$', '/') }}docker-compose-simple.yml" up -d --build
+  args:
+    chdir: "{{ docker_compose_project_path | regex_replace('//$', '/') }}"
+    executable: /bin/bash
+  environment:
+    COMPOSE_IGNORE_ORPHANS: "True"
+    PATH: "/usr/local/bin:/usr/bin:/bin"
+
+- name: Container-Status prüfen
+  ansible.builtin.shell: |
+    docker-compose -p michaelschiemer -f "{{ docker_compose_project_path | regex_replace('//$', '/') }}docker-compose-simple.yml" ps
+  args:
+    chdir: "{{ docker_compose_project_path | regex_replace('//$', '/') }}"
+    executable: /bin/bash
+  register: compose_ps
+
+- name: Container-Status anzeigen
+  ansible.builtin.debug:
+    var: compose_ps.stdout_lines
+
+- name: Docker-Fehlermeldungen anzeigen (falls vorhanden)
+  ansible.builtin.debug:
+    var: compose_ps.stderr_lines
+  when: compose_ps.stderr is defined and compose_ps.stderr != ""
+
+- name: Container-Logs anzeigen für Fehlersuche
+  ansible.builtin.shell: |
+    docker-compose -p michaelschiemer -f "{{ docker_compose_project_path | regex_replace('//$', '/') }}docker-compose-simple.yml" logs --tail=20
+  args:
+    chdir: "{{ docker_compose_project_path | regex_replace('//$', '/') }}"
+    executable: /bin/bash
+  register: compose_logs
+  ignore_errors: yes
+
+- name: Container-Logs ausgeben
+  ansible.builtin.debug:
+    var: compose_logs.stdout_lines
+  when: compose_logs.stdout is defined
diff --git a/x_ansible/playbooks/deploy/includes/docker_setup.yml b/x_ansible/playbooks/deploy/includes/docker_setup.yml
new file mode 100644
index 00000000..a1b8d2c8
--- /dev/null
+++ b/x_ansible/playbooks/deploy/includes/docker_setup.yml
@@ -0,0 +1,109 @@
+---
+# Datei: ansible/playbooks/deploy/includes/docker_setup.yml
+# Verwaltet die Docker-Umgebung und Grundkonfigurationen
+
+- name: Stelle sicher, dass die Docker-Verzeichnisstruktur existiert
+  file:
+    path: "{{ docker_compose_project_path }}/{{ item }}"
+    state: directory
+    mode: '0755'
+    recurse: yes
+  loop:
+    - "docker/php"
+    - "docker/nginx"
+    - "docker/redis"
+    - "src"
+    - "public"
+    - "cache"
+
+- name: Docker-Basis-Konfiguration erstellen für PHP
+  copy:
+    dest: "{{ docker_compose_project_path }}/docker/php/Dockerfile-simple"
+    content: |
+      FROM php:8.4-fpm
+
+      RUN apt-get update && apt-get install -y \
+          git \
+          unzip \
+          libzip-dev \
+          zip \
+          && docker-php-ext-install zip pdo pdo_mysql \
+          && docker-php-ext-install opcache \
+          && docker-php-ext-install pcntl posix shmop \
+          && apt-get clean \
+          && rm -rf /var/lib/apt/lists/*
+
+      WORKDIR /var/www/html
+
+      # Kein Composer-Befehl hier
+
+      CMD ["php-fpm"]
+    owner: root
+    group: root
+    mode: '0644'
+
+- name: Erstelle Nginx-Konfiguration
+  copy:
+    dest: "{{ docker_compose_project_path }}/docker/nginx/nginx.conf"
+    content: |
+      user  nginx;
+      worker_processes  auto;
+
+      error_log  /var/log/nginx/error.log warn;
+      pid        /var/run/nginx.pid;
+
+      events {
+          worker_connections  1024;
+      }
+
+      http {
+          include       /etc/nginx/mime.types;
+          default_type  application/octet-stream;
+
+          log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
+                            '$status $body_bytes_sent "$http_referer" '
+                            '"$http_user_agent" "$http_x_forwarded_for"';
+
+          access_log  /var/log/nginx/access.log  main;
+
+          sendfile        on;
+          keepalive_timeout  65;
+
+          include /etc/nginx/conf.d/*.conf;
+      }
+    mode: '0644'
+
+- name: Erstelle Nginx Default-Site-Konfiguration
+  copy:
+    dest: "{{ docker_compose_project_path }}/docker/nginx/default.conf"
+    content: |
+      server {
+          listen 80;
+          listen [::]:80;
+          server_name _;
+
+          root /var/www/html/public;
+          index index.php index.html;
+
+          location / {
+              try_files $uri $uri/ /index.php?$query_string;
+          }
+
+          location ~ \.php$ {
+              fastcgi_pass php:9000;
+              fastcgi_index index.php;
+              fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
+              include fastcgi_params;
+          }
+      }
+    mode: '0644'
+
+- name: Erstelle Redis-Konfiguration (falls benötigt)
+  copy:
+    dest: "{{ docker_compose_project_path }}/docker/redis/redis.conf"
+    content: |
+      # Redis Konfiguration
+      maxmemory 256mb
+      maxmemory-policy allkeys-lru
+    mode: '0644'
+  when: false  # Nur aktivieren, wenn Redis-Konfiguration benötigt wird
diff --git a/x_ansible/playbooks/deploy/includes/env_setup.yml b/x_ansible/playbooks/deploy/includes/env_setup.yml
new file mode 100644
index 00000000..372e2661
--- /dev/null
+++ b/x_ansible/playbooks/deploy/includes/env_setup.yml
@@ -0,0 +1,44 @@
+---
+# Datei: ansible/playbooks/deploy/includes/env_setup.yml
+# Verwaltet die Erstellung und Konfiguration von Umgebungsvariablen
+
+- name: Stelle sicher dass das Template-Verzeichnis existiert
+  file:
+    path: "{{ playbook_dir }}/../roles/deploy/templates"
+    state: directory
+    mode: '0755'
+  delegate_to: localhost
+  become: false
+  run_once: true
+
+- name: Erstelle .env-Template falls es nicht existiert
+  copy:
+    dest: "{{ playbook_dir }}/../roles/deploy/templates/.env.j2"
+    content: |
+      # Automatisch generierte .env-Datei
+      # Generiert durch Ansible am {{ ansible_date_time.date }}
+
+      COMPOSE_PROJECT_NAME={{ compose_project_name | default('michaelschiemer') }}
+
+      # Allgemeine Einstellungen
+      APP_NAME={{ app_name | default('michaelschiemer') }}
+      APP_ENV={{ env_vars.APP_ENV | default('production') }}
+      APP_DEBUG={{ env_vars.APP_DEBUG | default('false') }}
+      APP_PORT={{ env_vars.APP_PORT | default(80) }}
+      APP_SSL_PORT={{ env_vars.APP_SSL_PORT | default(443) }}
+
+      # Server-Konfiguration
+      APP_URL={{ 'https' if ssl_enabled | default(false) else 'http' }}://{{ app_domain }}
+    mode: '0644'
+  delegate_to: localhost
+  become: false
+  run_once: true
+
+- name: .env-Datei erstellen oder aktualisieren
+  template:
+    src: ../roles/deploy/templates/.env.j2
+    dest: "{{ deploy_root }}/.env"
+    owner: "{{ deploy_user }}"
+    group: "{{ deploy_user }}"
+    mode: '0644'
+  when: lookup('vars', 'env_vars', default=false)
diff --git a/x_ansible/playbooks/deploy/includes/project_sync.yml b/x_ansible/playbooks/deploy/includes/project_sync.yml
new file mode 100644
index 00000000..4971d412
--- /dev/null
+++ b/x_ansible/playbooks/deploy/includes/project_sync.yml
@@ -0,0 +1,67 @@
+---
+# Datei: ansible/playbooks/deploy/includes/project_sync.yml
+# Verwaltet die Synchronisierung von Projektdateien
+
+- name: Stelle sicher, dass das Zielverzeichnis existiert
+  file:
+    path: "{{ deploy_root }}"
+    state: directory
+    owner: "{{ deploy_user }}"
+    group: "{{ deploy_user }}"
+    mode: '0755'
+
+- name: Synchronisiere Projektdateien (wenn project_source definiert ist)
+  synchronize:
+    src: "{{ project_source }}/"
+    dest: "{{ deploy_root }}/"
+    delete: yes
+    rsync_opts:
+      - "--exclude=.git/"
+      - "--exclude=node_modules/"
+      - "--exclude=vendor/"
+      - "--exclude=.env.local"
+  when: lookup('vars', 'project_source', default=false)
+
+- name: SSL-Verzeichnis sicherstellen
+  file:
+    path: "{{ deploy_root }}/ssl"
+    state: directory
+    owner: "{{ deploy_user }}"
+    group: "{{ deploy_user }}"
+    mode: '0755'
+
+- name: Public-Verzeichnis sicherstellen
+  file:
+    path: "{{ deploy_root }}/public"
+    state: directory
+    owner: "{{ deploy_user }}"
+    group: "{{ deploy_user }}"
+    mode: '0755'
+
+- name: SSL-Zertifikate prüfen
+  stat:
+    path: "/etc/letsencrypt/live/{{ app_domain }}/fullchain.pem"
+  register: ssl_certs
+  when: ssl_enabled | default(false)
+
+- name: SSL-Zertifikate kopieren (falls vorhanden)
+  copy:
+    src: "{{ item.src }}"
+    dest: "{{ item.dest }}"
+    remote_src: yes
+    owner: "{{ deploy_user }}"
+    group: "{{ deploy_user }}"
+    mode: '0644'
+  loop:
+    - { src: "/etc/letsencrypt/live/{{ app_domain }}/fullchain.pem", dest: "{{ deploy_root }}/ssl/fullchain.pem" }
+    - { src: "/etc/letsencrypt/live/{{ app_domain }}/privkey.pem", dest: "{{ deploy_root }}/ssl/privkey.pem" }
+  when: ssl_enabled | default(false) and ssl_certs.stat.exists | default(false)
+
+- name: .env-Datei erstellen oder aktualisieren
+  template:
+    src: templates/.env.j2
+    dest: "{{ deploy_root }}/.env"
+    owner: "{{ deploy_user }}"
+    group: "{{ deploy_user }}"
+    mode: '0644'
+  when: lookup('vars', 'env_vars', default=false)
diff --git a/x_ansible/playbooks/deploy/includes/status_check.yml b/x_ansible/playbooks/deploy/includes/status_check.yml
new file mode 100644
index 00000000..2ff8b421
--- /dev/null
+++ b/x_ansible/playbooks/deploy/includes/status_check.yml
@@ -0,0 +1,36 @@
+# Diese Datei enthält wiederverwendbare Tasks für die Anwendungsstatusüberprüfung
+
+- name: Prüfe Anwendungsstatus
+  uri:
+    url: "http://{{ app_domain }}/"
+    return_content: no
+    status_code: 200, 301, 302, 403
+    validate_certs: no
+    timeout: 10
+  register: app_status
+  ignore_errors: yes
+  delegate_to: localhost
+  become: no
+  tags: [check]
+
+- name: Setze Standardwerte für app_status
+  set_fact:
+    app_status: { 'status': 'unbekannt' }
+  when: app_status is undefined or app_status.status is undefined
+  tags: [check]
+
+- name: Zeige Anwendungsstatus
+  debug:
+    msg: >
+      Anwendung ist
+      {% if app_status.status is defined and app_status.status == 200 %}
+        verfügbar
+      {% else %}
+        nicht verfügbar
+        {% if app_status.status is defined %}
+          (Status: {{ app_status.status }})
+        {% else %}
+          (Status konnte nicht ermittelt werden)
+        {% endif %}
+      {% endif %}
+  tags: [check]
diff --git a/x_ansible/playbooks/deploy/production.yml b/x_ansible/playbooks/deploy/production.yml
new file mode 100644
index 00000000..fd8240e8
--- /dev/null
+++ b/x_ansible/playbooks/deploy/production.yml
@@ -0,0 +1,98 @@
+- name: Deployment für PRODUCTION
+  hosts: production
+  become: true
+  gather_facts: false
+
+  vars:
+    docker_compose_project_path: "/var/www/www.michaelschiemer.de/"
+    env_file_path: "/var/www/www.michaelschiemer.de/.env"
+    deploy_root: /var/www/www.michaelschiemer.de
+    deploy_public: "{{ deploy_root }}/public"
+    deploy_user: deploy
+    app_domain: "michaelschiemer.de"
+    project_root: "{{ playbook_dir }}/../.."
+
+  roles:
+    - app
+    - nginx
+    - php
+    - redis
+---
+# Produktions-Deployment
+# Dieses Playbook steuert das Deployment in die Produktionsumgebung
+
+- name: Deployment für PRODUKTIONS-Umgebung
+  hosts: production
+  become: true
+  gather_facts: true
+
+  # Vorbereitung des Deployments
+  pre_tasks:
+    - name: Prüfe Verbindung zum Produktionsserver
+      ping:
+      register: ping_result
+      tags: [always, check]
+
+    - name: Zeige Serverinformationen
+      debug:
+        msg: "Verbunden mit {{ inventory_hostname }} ({{ ansible_host }})"
+      tags: [always, check]
+
+    - name: Sicherung der aktuellen Anwendung erstellen
+      shell: |
+        timestamp=$(date +%Y%m%d_%H%M%S)
+        mkdir -p {{ deploy_root }}_backups
+        tar -czf {{ deploy_root }}_backups/backup_$timestamp.tar.gz -C {{ deploy_root }} . || true
+      tags: [backup]
+
+  # Rollen für die Basiseinrichtung des Servers
+  roles:
+    - docker
+    - app
+    - nginx
+    - php
+    - redis
+
+  # Haupttasks für das Deployment
+  tasks:
+    - name: Synchronisiere Anwendungsdateien
+      synchronize:
+        src: "{{ project_source }}/"
+        dest: "{{ deploy_root }}/"
+        delete: yes
+        rsync_opts:
+          - "--exclude=.git/"
+          - "--exclude=node_modules/"
+          - "--exclude=vendor/"
+          - "--exclude=.env.local"
+      tags: [sync, files]
+
+    - name: Wende modulare Deployment-Tasks an
+      import_tasks: ../deploy/includes/deploy_common.yml
+      tags: [deploy]
+
+  # Nachbereitung nach dem Deployment
+  post_tasks:
+    - name: Prüfe Anwendungsstatus
+      uri:
+        url: "https://{{ app_domain }}/"
+        return_content: no
+        status_code: 200, 301, 302, 403
+        validate_certs: yes
+      register: app_status
+      ignore_errors: yes
+      delegate_to: localhost
+      tags: [check]
+
+    - name: Zeige Anwendungsstatus
+      debug:
+        msg: "Anwendung ist {% if app_status.status == 200 %}verfügbar{% else %}nicht verfügbar (Status: {{ app_status.status | default('unbekannt') }}){% endif %}"
+      tags: [check]
+
+    - name: Benachrichtigung über abgeschlossenes Deployment
+      debug:
+        msg: "Deployment in Produktionsumgebung abgeschlossen"
+      tags: [always, notify]
+  tasks:
+    - name: Common Deployment Tasks
+      import_tasks: ../deploy/includes/deploy_common.yml
diff --git a/x_ansible/playbooks/deploy/staging.yml b/x_ansible/playbooks/deploy/staging.yml
new file mode 100644
index 00000000..8b90f5c7
--- /dev/null
+++ b/x_ansible/playbooks/deploy/staging.yml
@@ -0,0 +1,304 @@
+---
+# Staging-Deployment
+# Dieses Playbook steuert das Deployment in die Staging-Umgebung
+
+- name: Deployment für STAGING-Umgebung
+  hosts: staging
+  become: true
+  gather_facts: true
+
+  vars:
+    # Deployment-Variablen
+    project_source: "{{ playbook_dir }}/../.."
+    deploy_root: /var/www/michaelschiemer
+    deploy_public: "{{ deploy_root }}/public"
+    docker_compose_project_path: "{{ deploy_root }}"
+
+  # Vorbereitung des Deployments
+  pre_tasks:
+    - name: Prüfe Verbindung zum Staging-Server
+      ping:
+      register: ping_result
+      tags: [always, check]
+
+    - name: Zeige Serverinformationen
+      debug:
+        msg: "Verbunden mit {{ inventory_hostname }} ({{ ansible_host }})"
+      tags: [always, check]
+
+  # Rollen für die Basiseinrichtung des Servers
+  roles:
+    - common
+    - docker
+    - app
+    - nginx
+    - php
+    - redis
+
+  # Haupttasks für das Deployment
+  tasks:
+    - name: Synchronisiere Anwendungsdateien
+      synchronize:
+        src: "{{ project_source }}/"
+        dest: "{{ deploy_root }}/"
+        delete: yes
+        rsync_opts:
+          - "--exclude=.git/"
+          - "--exclude=node_modules/"
+          - "--exclude=vendor/"
+          - "--exclude=.env.local"
+      tags: [sync, files]
+
+    - name: Wende modulare Deployment-Tasks an
+      import_tasks: ../deploy/includes/deploy_common.yml
+      tags: [deploy]
+
+  # Nachbereitung nach dem Deployment
+  post_tasks:
+    - name: Hole Server-IP-Adresse
+      shell: hostname -I | awk '{print $1}'
+      register: server_ip
+      ignore_errors: yes
+      tags: [check]
+
+    - name: Hole Nginx-Container-IP (vereinfacht)
+      shell: |
+        CONTAINER_ID=$(docker ps -q --filter name=michaelschiemer_nginx)
+        if [ -n "$CONTAINER_ID" ]; then
+          docker inspect $CONTAINER_ID | grep -m 1 '"IPAddress"' | awk -F '"' '{print $4}'
+        else
+          echo "Container nicht gefunden"
+        fi
+      register: container_ip
+      ignore_errors: yes
+      tags: [check]
+
+    - name: Warte kurz bis Docker-Container gestartet sind
+      pause:
+        seconds: 5
+      tags: [check]
+
+    - name: Überprüfe ob curl installiert ist
+      shell: which curl || echo "not found"
+      register: curl_check
+      ignore_errors: yes
+      tags: [check]
+
+    - name: Installiere curl falls notwendig
+      apt:
+        name: curl
+        state: present
+      when: curl_check.stdout == "not found"
+      tags: [check]
+
+    - name: Teste direkten Zugriff auf Nginx-Container via curl
+      shell: |
+        CONTAINER_IP=$(docker ps -q --filter name=michaelschiemer_nginx | xargs -I{} docker inspect {} --format='{{.NetworkSettings.Networks.frontend.IPAddress}}' 2>/dev/null || echo "nicht verfügbar")
+        if [ "$CONTAINER_IP" != "nicht verfügbar" ]; then
+          curl -s -I http://$CONTAINER_IP || echo "Verbindung fehlgeschlagen"
+        else
+          echo "Container-IP nicht verfügbar"
+        fi
+      register: curl_test
+      ignore_errors: yes
+      tags: [check]
+
+    - name: Teste lokalen Zugriff auf Port 80
+      shell: |
+        curl -s --connect-timeout 5 -I http://localhost:80 || curl -s --connect-timeout 5 -I http://127.0.0.1:80 || echo "Lokale Verbindung fehlgeschlagen"
+      register: curl_local_test
+      ignore_errors: yes
+      tags: [check]
+
+    - name: Teste direkten Zugriff auf Nginx-Container
+      shell: |
+        CONTAINER_ID=$(docker ps -q --filter name=michaelschiemer_nginx)
+        if [ -n "$CONTAINER_ID" ]; then
+          docker exec $CONTAINER_ID nginx -v || echo "Nginx-Befehl nicht verfügbar"
+        else
+          echo "Container nicht aktiv"
+        fi
+      register: nginx_version_test
+      ignore_errors: yes
+      tags: [check]
+
+    - name: Prüfe Docker-Container-Ports
+      shell: docker port michaelschiemer_nginx || echo "Container-Port-Informationen nicht verfügbar"
+      register: container_ports
+      ignore_errors: yes
+      tags: [check]
+
+    - name: Prüfe Anwendungsstatus über Server-IP
+      uri:
+        url: "http://{{ server_ip.stdout | trim }}/"
+        return_content: no
+        status_code: 200, 301, 302, 403, 404, 500, 502, 503
+        validate_certs: no
+        timeout: 10
+      register: app_status
+      ignore_errors: yes
+      delegate_to: localhost
+      become: no
+      tags: [check]
+
+    - name: Prüfe Anwendungsstatus über konfigurierte Domain (falls IP-Prüfung fehlschlägt)
+      uri:
+        url: "http://{{ app_domain }}/"
+        return_content: no
+        status_code: 200, 301, 302, 403, 404, 500, 502, 503
+        validate_certs: no
+        timeout: 10
+      register: app_status
+      ignore_errors: yes
+      delegate_to: localhost
+      become: no
+      when: app_status.status is defined and app_status.status|int < 0
+      tags: [check]
+
+    - name: Verarbeite app_status zu einem gültigen Wert
+      set_fact:
+        app_status_code: "{{ app_status.status|default('unbekannt') }}"
+      tags: [check]
+
+    - name: Debug app_status
+      debug:
+        msg: "Aktueller app_status: {{ app_status_code }}"
+      tags: [check]
+
+    - name: Prüfe Docker-Container-Status
+      shell: docker ps | grep nginx || echo "Kein Nginx-Container gefunden"
+      register: nginx_status
+      ignore_errors: yes
+      tags: [check]
+
+    - name: Ermittle Docker-Netzwerke
+      shell: docker network ls
+      register: docker_networks
+      ignore_errors: yes
+      tags: [check]
+
+    - name: Erstelle ein einfaches HTML-Testdokument im public-Verzeichnis
+      copy:
+        dest: "{{ deploy_root }}/public/index.html"
+        content: |
+          <!DOCTYPE html>
+          <html>
+          <head>
+              <title>Webserver ist aktiv</title>
+              <style>
+                  body { font-family: Arial, sans-serif; margin: 40px; line-height: 1.6; }
+                  h1 { color: #333; }
+                  .container { max-width: 800px; margin: 0 auto; padding: 20px; border: 1px solid #ddd; border-radius: 5px; }
+                  .success { color: green; }
+                  .info { margin-top: 20px; background: #f8f8f8; padding: 10px; border-radius: 5px; }
+              </style>
+          </head>
+          <body>
+              <div class="container">
+                  <h1>Webserver ist <span class="success">aktiv</span>!</h1>
+                  <p>Diese Seite bestätigt, dass der Nginx-Webserver korrekt läuft.</p>
+                  <div class="info">
+                      <h3>Server-Informationen:</h3>
+                      <p>Datum: {{ ansible_date_time.date | default('nicht verfügbar') }}</p>
+                      <p>Server: {{ inventory_hostname }}</p>
+                      <p>IP: {{ server_ip.stdout | trim | default('nicht verfügbar') }}</p>
+                      <p>Deployment-Zeit: {{ ansible_date_time.iso8601 | default('unbekannt') }}</p>
+                  </div>
+              </div>
+          </body>
+          </html>
+        mode: '0644'
+      tags: [check]
+
+    - name: Erstelle zusätzliche Test-Datei direkt im Webroot
+      copy:
+        dest: "{{ deploy_root }}/public/test.html"
+        content: |
+          <!DOCTYPE html>
+          <html>
+          <head>
+              <title>Nginx Test</title>
+          </head>
+          <body>
+              <h1>Nginx Test erfolgreich!</h1>
+              <p>Wenn Sie diese Seite sehen, funktioniert der Nginx-Webserver korrekt.</p>
+              <p>Server-IP: {{ server_ip.stdout | trim | default('nicht verfügbar') }}</p>
+          </body>
+          </html>
+        mode: '0644'
+      tags: [check]
+
+    - name: Hole Container-Informationen für Diagnose
+      shell: |
+        docker ps | grep michaelschiemer_nginx || echo "Container nicht gefunden"
+      register: container_info
+      ignore_errors: yes
+      tags: [check]
+
+    - name: Prüfe auf offene Ports
+      shell: |
+        ss -tulpn | grep LISTEN | grep ':80' || echo "Kein Prozess an Port 80 gebunden"
+      register: port_check
+      ignore_errors: yes
+      tags: [check]
+
+    - name: Zeige Anwendungsstatus und Server-Informationen
+      debug:
+        msg: |
+          Anwendungsstatus:
+          - Server IP: {{ server_ip.stdout | trim | default('nicht verfügbar') }}
+          - Domain: {{ app_domain }}
+          - Status: {% if app_status_code == 200 %}Verfügbar (HTTP 200 OK){% elif app_status_code|int > 0 %}Erreichbar aber mit Fehler (HTTP {{ app_status_code }}){% else %}Status konnte nicht ermittelt werden ({{ app_status_code }}){% endif %}
+
+          Docker-Container Status:
+          {{ nginx_status.stdout | default('Keine Informationen verfügbar') }}
+
+          Port-Status:
+          {{ port_80_check.stdout | default('Keine Port-Informationen verfügbar') }}
+
+          Lokaler Verbindungstest:
+          {{ curl_local_test.stdout | default('Keine Testinformationen verfügbar') }}
+
+          Nginx-Version im Container:
+          {{ nginx_version_test.stdout | default('Keine Versionsinformationen verfügbar') }}
+
+          Docker-Container sollte auf Port 80 verfügbar sein.
+
+          Lösungsvorschläge bei Verbindungsproblemen:
+          - Firewall-Regeln prüfen: sudo ufw status
+          - Nginx-Container-Logs prüfen: docker logs michaelschiemer_nginx
+          - Stellen Sie sicher, dass kein anderer Prozess Port 80 belegt: ss -tulpn | grep ':80'
+          - Container neu starten: cd {{ deploy_root }} && docker-compose -f docker-compose-simple.yml restart nginx
+          - Überprüfen Sie den Status: docker-compose -f {{ deploy_root }}/docker-compose-simple.yml ps
+      tags: [check]
+
+    - name: Prüfe Nginx-Container Status
+      shell: docker ps -a | grep michaelschiemer-nginx
+      register: nginx_container_status
+      ignore_errors: yes
+      tags: [check]
+
+    - name: Prüfe ob Port 80 offen ist
+      shell: netstat -tulpn | grep LISTEN | grep ':80'
+      register: port_80_status
+      ignore_errors: yes
+      tags: [check]
+
+    - name: Zeige Container-Status und Port-Informationen
+      debug:
+        msg: |
+          Nginx-Container Status:
+          {{ nginx_status.stdout | default('Container nicht gefunden') }}
+
+          Port 80 Status:
+          {{ port_80_check.stdout | default('Port 80 scheint nicht zu lauschen') }}
+
+          Server-IP: {{ server_ip.stdout | trim | default('nicht ermittelbar') }}
+
+          Diagnoseinformationen:
+          - Überprüfen Sie, ob der Container läuft: docker ps -a
+          - Prüfen Sie die Container-Logs: docker logs michaelschiemer_nginx
+          - Prüfen Sie die Container-Netzwerkeinstellungen: docker inspect michaelschiemer_nginx
+          - Stellen Sie sicher, dass der Host-Port 80 nicht bereits belegt ist
+          - Prüfen Sie die Firewall-Einstellungen: sudo ufw status
+      tags: [check]
diff --git a/x_ansible/playbooks/includes/deploy_common.yml b/x_ansible/playbooks/includes/deploy_common.yml
new file mode 100644
index 00000000..0afc3929
--- /dev/null
+++ b/x_ansible/playbooks/includes/deploy_common.yml
@@ -0,0 +1,103 @@
+---
+# Gemeinsame Tasks für alle Deployment-Szenarien
+
+- name: Stelle sicher, dass Zielverzeichnisse existieren
+  file:
+    path: "{{ item }}"
+    state: directory
+    owner: "{{ deploy_user }}"
+    group: "{{ deploy_user }}"
+    mode: '0755'
+  loop:
+    - "{{ deploy_root }}"
+    - "{{ deploy_root }}/public"
+    - "{{ deploy_root }}/ssl"
+    - "{{ deploy_root }}/src"
+    - "{{ deploy_root }}/docker"
+    - "{{ deploy_root }}/docker/nginx"
+    - "{{ deploy_root }}/docker/php"
+
+- name: SSL-Zertifikate prüfen
+  stat:
+    path: "/etc/letsencrypt/live/{{ app_domain }}/fullchain.pem"
+  register: ssl_certs
+
+- name: SSL-Zertifikate kopieren (falls vorhanden)
+  copy:
+    src: "{{ item.src }}"
+    dest: "{{ item.dest }}"
+    remote_src: yes
+    owner: "{{ deploy_user }}"
+    group: "{{ deploy_user }}"
+    mode: '0644'
+  loop:
+    - { src: "/etc/letsencrypt/live/{{ app_domain }}/fullchain.pem", dest: "{{ deploy_root }}/ssl/fullchain.pem" }
+    - { src: "/etc/letsencrypt/live/{{ app_domain }}/privkey.pem", dest: "{{ deploy_root }}/ssl/privkey.pem" }
+  when: ssl_certs.stat.exists
+
+- name: Kopiere Docker-Konfigurationen
+  copy:
+    src: "{{ playbook_dir }}/../docker/"
+    dest: "{{ deploy_root }}/docker/"
+    mode: '0644'
+
+- name: Kopiere docker-compose.yml
+  copy:
+    src: "{{ playbook_dir }}/../docker-compose.yml"
+    dest: "{{ deploy_root }}/docker-compose.yml"
+    mode: '0644'
+
+- name: Erstelle .env-Datei
+  copy:
+    dest: "{{ deploy_root }}/.env"
+    content: |
+      COMPOSE_PROJECT_NAME=michaelschiemer
+      APP_ENV={{ environment | default('production') }}
+      APP_DOMAIN={{ app_domain }}
+      DEPLOY_ROOT={{ deploy_root }}
+    owner: "{{ deploy_user }}"
+    group: "{{ deploy_user }}"
+    mode: '0644'
+
+- name: Starte Docker-Container
+  shell: |
+    cd {{ deploy_root }} && \
+    docker-compose up -d --build
+  args:
+    chdir: "{{ deploy_root }}"
+  environment:
+    COMPOSE_IGNORE_ORPHANS: "True"
+    PATH: "/usr/local/bin:/usr/bin:/bin"
+
+- name: Warte kurz bis Docker-Container gestartet sind
+  pause:
+    seconds: 5
+
+- name: Erstelle Test-HTML-Datei
+  copy:
+    dest: "{{ deploy_root }}/public/index.html"
+    content: |
+      <!DOCTYPE html>
+      <html>
+      <head>
+          <title>Server aktiv</title>
+          <style>
+              body { font-family: Arial, sans-serif; margin: 40px; }
+              h1 { color: #3273dc; }
+              .container { max-width: 800px; margin: 0 auto; padding: 20px; border: 1px solid #eee; border-radius: 5px; }
+              .info { margin-top: 20px; background: #f8f8f8; padding: 10px; border-radius: 5px; }
+          </style>
+      </head>
+      <body>
+          <div class="container">
+              <h1>Server ist aktiv!</h1>
+              <p>Diese Seite bestätigt, dass der Webserver korrekt läuft.</p>
+              <div class="info">
+                  <p>Server: {{ inventory_hostname }}</p>
+                  <p>Umgebung: {{ environment | default('unbekannt') }}</p>
+                  <p>Deployment-Zeit: {{ ansible_date_time.iso8601 | default('unbekannt') }}</p>
+              </div>
+          </div>
+      </body>
+      </html>
+    mode: '0644'
diff --git a/x_ansible/playbooks/setup.yml b/x_ansible/playbooks/setup.yml
new file mode 100644
index 00000000..cd2fb7b9
--- /dev/null
+++ b/x_ansible/playbooks/setup.yml
@@ -0,0 +1,81 @@
+---
+- name: Basis Setup für alle Zielsysteme
+  hosts: web
+  become: true
+  gather_facts: true
+
+  pre_tasks:
+    - name: Überprüfe Serververbindung
+      ping:
+      tags: [always, check]
+
+    - name: Zeige Server-Informationen
+      debug:
+        msg: "Verbunden mit {{ inventory_hostname }} ({{ ansible_host | default('IP unbekannt') }})"
+      tags: [always, check]
+
+  roles:
+    - common
+    - docker
+
+  post_tasks:
+    - name: Stelle sicher, dass Zielverzeichnisse existieren
+      file:
+        path: "{{ item }}"
+        state: directory
+        owner: "{{ deploy_user }}"
+        group: "{{ deploy_user }}"
+        mode: '0755'
+      loop:
+        - "{{ deploy_root }}"
+        - "{{ deploy_root }}/public"
+        - "{{ deploy_root }}/ssl"
+        - "{{ deploy_root }}/src"
+        - "{{ deploy_root }}/docker"
+        - "{{ deploy_root }}/docker/nginx"
+        - "{{ deploy_root }}/docker/php"
+      tags: [setup, folders]
+
+    - name: Kopiere Docker-Konfigurationen
+      synchronize:
+        src: "{{ playbook_dir }}/docker/"
+        dest: "{{ deploy_root }}/docker/"
+        delete: yes
+      tags: [setup, docker]
+
+    - name: Kopiere docker-compose.yml
+      copy:
+        src: "{{ playbook_dir }}/docker-compose.yml"
+        dest: "{{ deploy_root }}/docker-compose.yml"
+        mode: '0644'
+        owner: "{{ deploy_user }}"
+        group: "{{ deploy_user }}"
+      tags: [setup, docker]
+
+    - name: Erstelle Test-HTML-Datei
+      copy:
+        dest: "{{ deploy_root }}/public/index.html"
+        content: |
+          <!DOCTYPE html>
+          <html>
+          <head>
+              <title>Server Setup erfolgreich</title>
+              <style>
+                  body { font-family: Arial, sans-serif; margin: 40px; }
+                  h1 { color: #3273dc; }
+                  .container { max-width: 800px; margin: 0 auto; padding: 20px; border: 1px solid #eee; border-radius: 5px; }
+              </style>
+          </head>
+          <body>
+              <div class="container">
+                  <h1>Server-Setup erfolgreich!</h1>
+                  <p>Diese Seite bestätigt, dass die grundlegende Servereinrichtung abgeschlossen ist.</p>
+                  <p>Als nächstes können Sie das Deployment ausführen mit:</p>
+                  <pre>./ansible/deploy.sh {{ environment | default('staging') }}</pre>
+              </div>
+          </body>
+          </html>
+        mode: '0644'
+        owner: "{{ deploy_user }}"
+        group: "{{ deploy_user }}"
+      tags: [setup, test]
diff --git a/x_ansible/playbooks/simplified-deploy.yml b/x_ansible/playbooks/simplified-deploy.yml
new file mode 100644
index 00000000..5bcc879f
--- /dev/null
+++ b/x_ansible/playbooks/simplified-deploy.yml
@@ -0,0 +1,250 @@
+---
+- name: Vereinfachtes Deployment mit Docker
+  hosts: all
+  become: true
+  gather_facts: true
+
+  vars:
+    deploy_root: /var/www/michaelschiemer
+    deploy_user: "{{ ansible_user | default('deploy') }}"
+    app_domain: "{{ hostvars[inventory_hostname]['ansible_host'] | default(inventory_hostname) }}"
+
+  tasks:
+    # 1. Grundlegende Server-Einrichtung
+    - name: Installiere grundlegende Pakete
+      apt:
+        name: [curl, ca-certificates, gnupg, apt-transport-https, software-properties-common, iproute2]
+        state: present
+        update_cache: yes
+
+    # 2. Docker Installation
+    - name: Docker GPG-Schlüssel hinzufügen
+      apt_key:
+        url: https://download.docker.com/linux/{{ ansible_distribution | lower }}/gpg
+        state: present
+
+    - name: Docker Repository hinzufügen
+      apt_repository:
+        repo: "deb [arch=amd64] https://download.docker.com/linux/{{ ansible_distribution | lower }} {{ ansible_distribution_release }} stable"
+        state: present
+
+    - name: Docker Engine installieren
+      apt:
+        name: [docker-ce, docker-ce-cli, containerd.io, docker-compose-plugin]
+        state: present
+        update_cache: yes
+
+    - name: Benutzer zur Docker-Gruppe hinzufügen
+      user:
+        name: "{{ ansible_user }}"
+        groups: docker
+        append: yes
+
+    - name: Docker-Service aktivieren
+      service:
+        name: docker
+        state: started
+        enabled: yes
+
+    # 3. Verzeichnisstruktur anlegen
+    - name: Stelle sicher, dass die Verzeichnisse existieren
+      file:
+        path: "{{ deploy_root }}/{{ item }}"
+        state: directory
+        mode: '0755'
+        owner: "{{ deploy_user }}"
+        group: "{{ deploy_user }}"
+        recurse: yes
+      loop:
+        - public
+        - docker/nginx
+        - docker/php
+        - src
+
+    # 4. Docker-Compose Datei erstellen
+    - name: Erstelle docker-compose.yml
+      copy:
+        dest: "{{ deploy_root }}/docker-compose.yml"
+        content: |
+          version: '3.8'
+
+          services:
+            php:
+              container_name: michaelschiemer_php
+              image: php:8.4-fpm
+              volumes:
+                - ./src:/var/www/html/src:rw
+                - ./public:/var/www/html/public:rw
+              networks:
+                - backend
+
+            nginx:
+              container_name: michaelschiemer_nginx
+              image: nginx:alpine
+              ports:
+                - "80:80"
+                - "443:443"
+              volumes:
+                - ./public:/var/www/html/public:ro
+                - ./docker/nginx/nginx.conf:/etc/nginx/nginx.conf:ro
+                - ./docker/nginx/default.conf:/etc/nginx/conf.d/default.conf:ro
+              depends_on:
+                - php
+              networks:
+                - frontend
+                - backend
+
+          networks:
+            frontend:
+            backend:
+        owner: "{{ deploy_user }}"
+        group: "{{ deploy_user }}"
+        mode: '0644'
+
+    # 5. Nginx Konfiguration erstellen
+    - name: Erstelle Nginx-Konfiguration
+      copy:
+        dest: "{{ deploy_root }}/docker/nginx/nginx.conf"
+        content: |
+          user  nginx;
+          worker_processes  auto;
+
+          error_log  /var/log/nginx/error.log warn;
+          pid        /var/run/nginx.pid;
+
+          events {
+              worker_connections  1024;
+          }
+
+          http {
+              include       /etc/nginx/mime.types;
+              default_type  application/octet-stream;
+
+              log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
+                                '$status $body_bytes_sent "$http_referer" '
+                                '"$http_user_agent" "$http_x_forwarded_for"';
+
+              access_log  /var/log/nginx/access.log  main;
+
+              sendfile        on;
+              keepalive_timeout  65;
+              include /etc/nginx/conf.d/*.conf;
+          }
+        mode: '0644'
+
+    - name: Erstelle Nginx Default-Site-Konfiguration
+      copy:
+        dest: "{{ deploy_root }}/docker/nginx/default.conf"
+        content: |
+          server {
+              listen 80;
+              listen [::]:80;
+              server_name _;
+
+              root /var/www/html/public;
+              index index.html index.php;
+
+              location / {
+                  try_files $uri $uri/ /index.php?$query_string;
+              }
+
+              location ~ \.php$ {
+                  fastcgi_pass php:9000;
+                  fastcgi_index index.php;
+                  fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
+                  include fastcgi_params;
+              }
+          }
+        mode: '0644'
+
+    # 6. Test HTML-Datei erstellen
+    - name: Erstelle Testseite
+      copy:
+        dest: "{{ deploy_root }}/public/index.html"
+        content: |
+          <!DOCTYPE html>
+          <html>
+          <head>
+              <title>Webserver ist aktiv</title>
+              <style>
+                  body { font-family: Arial, sans-serif; margin: 40px; line-height: 1.6; }
+                  h1 { color: #333; }
+                  .container { max-width: 800px; margin: 0 auto; padding: 20px; border: 1px solid #ddd; border-radius: 5px; }
+                  .success { color: green; }
+                  .info { margin-top: 20px; background: #f8f8f8; padding: 10px; border-radius: 5px; }
+              </style>
+          </head>
+          <body>
+              <div class="container">
+                  <h1>Webserver ist <span class="success">aktiv</span>!</h1>
+                  <p>Diese Seite bestätigt, dass der Nginx-Webserver korrekt läuft.</p>
+                  <div class="info">
+                      <h3>Server-Informationen:</h3>
+                      <p>Server: {{ inventory_hostname }}</p>
+                      <p>IP: {{ ansible_default_ipv4.address }}</p>
+                      <p>Deployment-Zeit: {{ ansible_date_time.iso8601 }}</p>
+                  </div>
+              </div>
+          </body>
+          </html>
+        mode: '0644'
+
+    # 7. Container starten
+    - name: Stoppe alle vorhandenen Container
+      command: docker-compose down --remove-orphans
+      args:
+        chdir: "{{ deploy_root }}"
+      ignore_errors: yes
+
+    - name: Starte Docker-Container
+      command: docker-compose up -d
+      args:
+        chdir: "{{ deploy_root }}"
+
+    # 8. Status und Tests
+    - name: Warte kurz bis Docker-Container gestartet sind
+      pause:
+        seconds: 5
+
+    - name: Server-IP ermitteln
+      shell: hostname -I | awk '{print $1}'
+      register: server_ip
+      ignore_errors: yes
+
+    - name: Prüfe Nginx-Container Status
+      shell: docker ps | grep nginx || echo "Kein Nginx-Container gefunden"
+      register: nginx_status
+      ignore_errors: yes
+
+    - name: Prüfe ob Port 80 offen ist
+      shell: ss -tulpn | grep LISTEN | grep ':80' || echo "Kein Prozess an Port 80 gebunden"
+      register: port_80_check
+      ignore_errors: yes
+
+    - name: Teste lokalen Zugriff auf Port 80
+      shell: curl -s --connect-timeout 5 -I http://localhost:80 || curl -s --connect-timeout 5 -I http://127.0.0.1:80 || echo "Lokale Verbindung fehlgeschlagen"
+      register: curl_local_test
+      ignore_errors: yes
+
+    - name: Zeige Anwendungsstatus und Server-Informationen
+      debug:
+        msg: |
+          Anwendungsstatus:
+          - Server IP: {{ server_ip.stdout | trim | default('nicht verfügbar') }}
+          - Domain: {{ app_domain }}
+
+          Docker-Container Status:
+          {{ nginx_status.stdout | default('Keine Informationen verfügbar') }}
+
+          Port-Status:
+          {{ port_80_check.stdout | default('Keine Port-Informationen verfügbar') }}
+
+          Lokaler Verbindungstest:
+          {{ curl_local_test.stdout | default('Keine Testinformationen verfügbar') }}
+
+          Docker-Container sollte auf Port 80 verfügbar sein.
+
+          Lösungsvorschläge bei Verbindungsproblemen:
+          - Firewall-Regeln prüfen: sudo ufw status
+          - Container-Logs prüfen: docker logs michaelschiemer_nginx
+          - Container neu starten: cd {{ deploy_root }} && docker-compose restart nginx
diff --git a/ansible/playbooks/test.yml b/x_ansible/playbooks/test.yml
similarity index 100%
rename from ansible/playbooks/test.yml
rename to x_ansible/playbooks/test.yml
diff --git a/ansible/playbooks/wireguard.yml b/x_ansible/playbooks/wireguard.yml
similarity index 100%
rename from ansible/playbooks/wireguard.yml
rename to x_ansible/playbooks/wireguard.yml
diff --git a/x_ansible/roles/app/defaults/main.yml b/x_ansible/roles/app/defaults/main.yml
new file mode 100644
index 00000000..671b9a8d
--- /dev/null
+++ b/x_ansible/roles/app/defaults/main.yml
@@ -0,0 +1,44 @@
+---
+# Standardwerte für die App-Rolle
+# Standardwerte für die App-Rolle
+
+# Deployment-Verzeichnisse
+deploy_root: /var/www/michaelschiemer
+deploy_public: "{{ deploy_root }}/public"
+
+# Benutzer
+deploy_user: "{{ ansible_user | default('deploy') }}"
+
+# Quellverzeichnis für Dateisynchronisation
+project_source: "{{ playbook_dir | dirname | dirname }}"
+
+# Domain
+app_domain: "localhost"
+---
+# Standardwerte für die App-Rolle
+---
+# Standardwerte für die App-Rolle
+
+# Deployment-Verzeichnisse
+deploy_root: /var/www/michaelschiemer
+deploy_public: "{{ deploy_root }}/public"
+
+# Benutzer
+deploy_user: "{{ ansible_user | default('deploy') }}"
+# Deployment-Variablen
+deploy_root: /var/www/michaelschiemer
+deploy_public: "{{ deploy_root }}/public"
+deploy_user: deploy
+
+# Anwendungsvariablen
+app_domain: "{{ hostvars[inventory_hostname]['ansible_host'] | default(inventory_hostname) }}"
+project_source: "{{ playbook_dir }}/../.."
+project_root: "{{ playbook_dir }}/../.."
+# Docker-Compose-Pfad
+docker_compose_project_path: "{{ deploy_root }}"
+# Diese Werte werden nur verwendet, wenn sie nicht anderweitig definiert sind
+deploy_root: /var/www/michaelschiemer
+deploy_public: "{{ deploy_root }}/public"
+deploy_user: "{{ ansible_user | default('deploy') }}"
+app_domain: "localhost"
+project_root: "{{ playbook_dir | dirname }}"
diff --git a/x_ansible/roles/app/tasks/main.yml b/x_ansible/roles/app/tasks/main.yml
new file mode 100644
index 00000000..45fb1e4e
--- /dev/null
+++ b/x_ansible/roles/app/tasks/main.yml
@@ -0,0 +1,622 @@
+---
+- name: Prüfe erforderliche Variablen
+  assert:
+    that:
+      - deploy_root is defined
+      - deploy_user is defined
+    fail_msg: "Erforderliche Variablen fehlen: deploy_root und/oder deploy_user nicht definiert"
+    success_msg: "Alle erforderlichen Variablen sind korrekt definiert"
+  tags: [always]
+
+- name: Projektverzeichnisse erstellen
+  file:
+    path: "{{ item }}"
+    state: directory
+    owner: "{{ deploy_user }}"
+    group: "{{ deploy_user }}"
+    mode: '0755'
+  loop:
+    - "{{ deploy_root }}"
+    - "{{ deploy_root }}/ssl"
+    - "{{ deploy_root }}/public"
+    - "{{ deploy_root }}/src"
+    - "{{ deploy_root }}/docker"
+
+- name: SSL-Zertifikate prüfen
+  stat:
+    path: "/etc/letsencrypt/live/{{ app_domain }}/fullchain.pem"
+  register: ssl_certs
+
+- name: SSL-Zertifikate kopieren (falls vorhanden)
+  copy:
+    src: "{{ item.src }}"
+    dest: "{{ item.dest }}"
+    remote_src: yes
+    owner: "{{ deploy_user }}"
+    group: "{{ deploy_user }}"
+    mode: '0644'
+  loop:
+    - { src: "/etc/letsencrypt/live/{{ app_domain }}/fullchain.pem", dest: "{{ deploy_root }}/ssl/fullchain.pem" }
+    - { src: "/etc/letsencrypt/live/{{ app_domain }}/privkey.pem", dest: "{{ deploy_root }}/ssl/privkey.pem" }
+  when: ssl_certs.stat.exists
+
+- name: Lokales public-Verzeichnis prüfen
+  stat:
+    path: "{{ playbook_dir }}/../../public"
+  register: public_dir
+  delegate_to: localhost
+  become: false
+
+- name: public-Verzeichnis synchronisieren
+  synchronize:
+    src: "{{ playbook_dir }}/../../public/"
+    dest: "{{ deploy_public }}/"
+    delete: yes
+    recursive: yes
+  when: public_dir.stat.exists and public_dir.stat.isdir
+
+- name: Lokale docker-compose.yml Datei prüfen
+  stat:
+    path: "{{ playbook_dir }}/../../docker-compose.yml"
+  register: docker_compose_file
+  delegate_to: localhost
+  become: false
+
+- name: Projekt-Stammdaten kopieren
+  copy:
+    src: "{{ playbook_dir }}/../../docker-compose.yml"
+    dest: "{{ deploy_root }}/docker-compose.yml"
+    owner: "{{ deploy_user }}"
+    group: "{{ deploy_user }}"
+    mode: '0644'
+  when: docker_compose_file.stat.exists
+
+
+
+- name: .env-Datei prüfen
+  stat:
+    path: "{{ project_root }}/.env"
+  register: env_file
+  delegate_to: localhost
+  become: false
+
+- name: .env kopieren (falls vorhanden)
+  copy:
+    src: "{{ project_root }}/.env"
+    dest: "{{ deploy_root }}/.env"
+    owner: "{{ deploy_user }}"
+    group: "{{ deploy_user }}"
+    mode: '0644'
+  when: env_file.stat.exists
+
+- name: Erstelle Standard-.env-Datei, wenn keine existiert
+  copy:
+    dest: "{{ deploy_root }}/.env"
+    content: |
+      COMPOSE_PROJECT_NAME=michaelschiemer
+    owner: "{{ deploy_user }}"
+    group: "{{ deploy_user }}"
+    mode: '0644'
+  when: not env_file.stat.exists
+
+
+- name: Lokales src-Verzeichnis prüfen
+  stat:
+    path: "{{ playbook_dir }}/../../src"
+  register: src_dir
+  delegate_to: localhost
+  become: false
+
+- name: Quellcode synchronisieren
+  synchronize:
+    src: "{{ playbook_dir }}/../../src/"
+    dest: "{{ deploy_root }}/src/"
+    delete: yes
+    recursive: yes
+  when: src_dir.stat.exists and src_dir.stat.isdir
+
+
+- name: Docker-Verzeichnis prüfen
+  stat:
+    path: "{{ project_root }}/docker"
+  register: docker_dir
+  delegate_to: localhost
+  become: false
+
+- name: Docker-Configs synchronisieren (falls vorhanden)
+  synchronize:
+    src: "{{ project_root }}/docker/"
+    dest: "{{ deploy_root }}/docker/"
+    delete: yes
+    recursive: yes
+  when: docker_dir.stat.exists
+
+- name: Rechte im Zielverzeichnis korrigieren
+  file:
+    path: "{{ deploy_root }}"
+    state: directory
+    owner: "{{ deploy_user }}"
+    group: "{{ deploy_user }}"
+    mode: '0755'
+    recurse: yes
+
+# Cache-Verzeichnis für UID/GID 1000 (z.B. appuser im Container)
+- name: Stelle Schreibrechte für Cache-Verzeichnis her
+  file:
+    path: "{{ deploy_root }}/cache"
+    state: directory
+    owner: 1000
+    group: 1000
+    mode: '0775'
+    recurse: yes
+
+
+- name: Erstelle .env-Datei für Docker Compose
+  copy:
+    dest: "{{ deploy_root }}/.env"
+    content: |
+      COMPOSE_PROJECT_NAME=michaelschiemer
+      APP_ENV=production
+      APP_PORT=80
+      APP_SSL_PORT=443
+      COMPOSER_INSTALL_FLAGS=--no-dev --optimize-autoloader
+    owner: "{{ deploy_user }}"
+    group: "{{ deploy_user }}"
+    mode: '0644'
+  when: not env_file.stat.exists
+
+- name: Prüfe docker-compose.yml im project_root
+  stat:
+    path: "{{ project_root }}/docker-compose.yml"
+  register: compose_file
+  delegate_to: localhost
+  become: false
+
+- name: Docker-Compose-Konfiguration für Deployment anpassen
+  copy:
+    dest: "{{ deploy_root }}/docker-compose-deploy.yml"
+    content: |
+      version: '3.8'
+
+      services:
+        php:
+          build:
+            context: {{ deploy_root }}/docker/php
+            dockerfile: Dockerfile-simple
+          volumes:
+            - {{ deploy_root }}/src:/var/www/html/src:rw
+            - {{ deploy_root }}/public:/var/www/html/public:rw
+          networks:
+            - backend
+
+        nginx:
+          image: nginx:alpine
+          ports:
+            - "80:80"
+            - "443:443"
+          volumes:
+            - {{ deploy_root }}/public:/var/www/html/public:ro
+            - {{ deploy_root }}/docker/nginx/nginx.conf:/etc/nginx/nginx.conf:ro
+            - {{ deploy_root }}/docker/nginx/default.conf:/etc/nginx/conf.d/default.conf:ro
+          depends_on:
+            - php
+          networks:
+            - frontend
+            - backend
+
+        redis:
+          image: redis:alpine
+          networks:
+            - cache
+
+      networks:
+        frontend:
+        backend:
+        cache:
+    owner: "{{ deploy_user }}"
+    group: "{{ deploy_user }}"
+    mode: '0644'
+
+- name: Stelle sicher, dass die Nginx-Verzeichnisstruktur korrekt ist
+  file:
+    path: "{{ deploy_root }}/docker/nginx"
+    state: directory
+    mode: '0755'
+
+- name: Bereinige nginx.conf Verzeichnis falls es existiert
+  shell: |
+    if [ -d "{{ deploy_root }}/docker/nginx/nginx.conf" ]; then
+      rm -rf "{{ deploy_root }}/docker/nginx/nginx.conf"
+    fi
+  args:
+    executable: /bin/bash
+  ignore_errors: yes
+
+- name: Erstelle Dockerfile für Nginx
+  copy:
+    dest: "{{ deploy_root }}/docker/nginx/Dockerfile"
+    content: |
+      FROM nginx:alpine
+
+      # Konfigurationen kopieren
+      COPY nginx.conf /etc/nginx/nginx.conf
+      COPY default.conf /etc/nginx/conf.d/default.conf
+
+      # Erstelle Verzeichnis für SSL
+      RUN mkdir -p /etc/nginx/ssl
+
+      # Starte nginx im Vordergrund
+      CMD ["nginx", "-g", "daemon off;"]
+    mode: '0644'
+
+- name: Docker-Compose-Datei für Deployment anpassen (PHP Dockerfile)
+  replace:
+    path: "{{ deploy_root }}/docker-compose-deploy.yml"
+    regexp: 'dockerfile: docker/php/Dockerfile'
+    replace: 'dockerfile: {{ deploy_root }}/docker/php/Dockerfile'
+---
+# App Deployment Tasks
+
+- name: Prüfe erforderliche Variablen
+  assert:
+    that:
+      - deploy_root is defined
+      - deploy_user is defined
+    fail_msg: "Erforderliche Variablen fehlen: deploy_root und/oder deploy_user nicht definiert"
+    success_msg: "Alle erforderlichen Variablen sind korrekt definiert"
+  tags: [always]
+
+- name: Projektverzeichnisse erstellen
+  file:
+    path: "{{ item }}"
+    state: directory
+    owner: "{{ deploy_user }}"
+    group: "{{ deploy_user }}"
+    mode: '0755'
+  loop:
+    - "{{ deploy_root }}"
+    - "{{ deploy_root }}/ssl"
+    - "{{ deploy_root }}/public"
+    - "{{ deploy_root }}/src"
+    - "{{ deploy_root }}/docker"
+
+- name: Erstelle einfache Test-HTML-Datei
+  copy:
+    dest: "{{ deploy_root }}/public/index.html"
+    content: |
+      <!DOCTYPE html>
+      <html>
+      <head>
+          <title>App ist aktiv</title>
+          <style>
+              body { font-family: Arial, sans-serif; margin: 40px; }
+              h1 { color: #3273dc; }
+              .container { max-width: 800px; margin: 0 auto; padding: 20px; border: 1px solid #eee; border-radius: 5px; }
+          </style>
+      </head>
+      <body>
+          <div class="container">
+              <h1>Anwendung ist aktiv!</h1>
+              <p>Diese Seite bestätigt, dass das App-Deployment erfolgreich war.</p>
+              <p>Server: {{ inventory_hostname }}</p>
+          </div>
+      </body>
+      </html>
+    mode: '0644'
+    owner: "{{ deploy_user }}"
+    group: "{{ deploy_user }}"
+- name: Docker-Compose-Datei für Deployment anpassen (Nginx Context)
+  replace:
+    path: "{{ deploy_root }}/docker-compose-deploy.yml"
+    regexp: 'context: docker/nginx'
+    replace: 'context: {{ deploy_root }}/docker/nginx'
+
+- name: Docker-Volumes in docker-compose.yml anpassen (korrigiert)
+  replace:
+    path: "{{ deploy_root }}/docker-compose-deploy.yml"
+    regexp: '(\s+-)?\s+\./(.+?)(?::cached|:delegated)?(?::rw|:ro)?$'
+    replace: '\1 {{ deploy_root }}/\2'
+  with_items:
+    - volumes
+    - volume
+
+- name: Docker-Volumes für Redis anpassen
+  replace:
+    path: "{{ deploy_root }}/docker-compose-deploy.yml"
+    regexp: '\./docker/redis/redis.conf'
+    replace: '{{ deploy_root }}/docker/redis/redis.conf'
+
+- name: Korrigiere spezielle Volume-Optionen (cached, delegated)
+  replace:
+    path: "{{ deploy_root }}/docker-compose-deploy.yml"
+    regexp: '{{ deploy_root }}/([^:]+):cached'
+    replace: '{{ deploy_root }}/\1:rw'
+
+- name: Korrigiere spezielle Volume-Optionen (delegated)
+  replace:
+    path: "{{ deploy_root }}/docker-compose-deploy.yml"
+    regexp: '{{ deploy_root }}/([^:]+):delegated'
+    replace: '{{ deploy_root }}/\1:rw'
+
+- name: Finde und korrigiere ungültige Volume-Spezifikationen
+  shell: |
+    sed -i 's|{{ deploy_root }}/var/www/html:|{{ deploy_root }}:|g' {{ deploy_root }}/docker-compose-deploy.yml
+    sed -i 's|:cached:rw|:rw|g' {{ deploy_root }}/docker-compose-deploy.yml
+    sed -i 's|:delegated:rw|:rw|g' {{ deploy_root }}/docker-compose-deploy.yml
+    cat {{ deploy_root }}/docker-compose-deploy.yml | grep -A 20 volumes
+  args:
+    chdir: "{{ deploy_root }}"
+  register: volume_debug
+
+- name: Erstelle einfache Docker Compose-Datei als Fallback
+  copy:
+    dest: "{{ deploy_root }}/docker-compose-simple.yml"
+    content: |
+      version: '3.8'
+
+      services:
+        php:
+          build:
+            context: {{ deploy_root }}/docker/php
+            dockerfile: Dockerfile-simple
+          volumes:
+            - {{ deploy_root }}/src:/var/www/html/src:rw
+            - {{ deploy_root }}/public:/var/www/html/public:rw
+          networks:
+            - backend
+
+        nginx:
+          image: nginx:alpine
+          ports:
+            - "80:80"
+            - "443:443"
+          volumes:
+            - {{ deploy_root }}/public:/var/www/html/public:ro
+            - {{ deploy_root }}/docker/nginx/nginx.conf:/etc/nginx/nginx.conf:ro
+          depends_on:
+            - php
+          networks:
+            - frontend
+            - backend
+
+        redis:
+          image: redis:alpine
+          networks:
+            - cache
+
+      networks:
+        frontend:
+        backend:
+        cache:
+    owner: "{{ deploy_user }}"
+    group: "{{ deploy_user }}"
+    mode: '0644'
+
+- name: Erstelle composer.lock-Datei wenn diese nicht existiert
+  file:
+    path: "{{ deploy_root }}/composer.lock"
+    state: touch
+    owner: "{{ deploy_user }}"
+    group: "{{ deploy_user }}"
+    mode: '0644'
+  register: composer_lock_created
+
+- name: Prüfe ob Dockerfile existiert
+  stat:
+    path: "{{ project_root }}/docker/php/Dockerfile"
+  register: dockerfile_exists
+  delegate_to: localhost
+  become: false
+
+- name: Erstelle angepasste Dockerfile für PHP
+  copy:
+    dest: "{{ deploy_root }}/docker/php/Dockerfile-deploy"
+    content: |
+      FROM php:8.4-fpm
+
+      RUN apt-get update && apt-get install -y \
+          git \
+          unzip \
+          libzip-dev \
+          zip \
+          && docker-php-ext-install zip pdo pdo_mysql \
+          && docker-php-ext-install opcache \
+          && docker-php-ext-install pcntl posix shmop \
+          && apt-get clean \
+          && rm -rf /var/lib/apt/lists/*
+
+      WORKDIR /var/www/html
+
+      # Kopiere Projektdateien
+      COPY . /var/www/html/
+
+      # Stelle sicher, dass der Webserver Zugriff auf Dateien hat
+      RUN chown -R www-data:www-data /var/www/html
+
+      CMD ["php-fpm"]
+    owner: "{{ deploy_user }}"
+    group: "{{ deploy_user }}"
+    mode: '0644'
+
+# Task entfernt, da wir jetzt direkt eine vollständige Dockerfile erstellen
+# und nicht mehr eine vorhandene Datei anpassen müssen
+
+- name: Erstelle vereinfachte Dockerfile für PHP
+  copy:
+    dest: "{{ deploy_root }}/docker/php/Dockerfile-simple"
+    content: |
+      FROM php:8.4-fpm
+
+      RUN apt-get update && apt-get install -y \
+          git \
+          unzip \
+          libzip-dev \
+          zip \
+          && docker-php-ext-install zip pdo pdo_mysql \
+          && docker-php-ext-install opcache \
+          && docker-php-ext-install pcntl posix shmop \
+          && apt-get clean \
+          && rm -rf /var/lib/apt/lists/*
+
+      WORKDIR /var/www/html
+
+      # Kein Composer-Befehl hier
+
+      CMD ["php-fpm"]
+    owner: "{{ deploy_user }}"
+    group: "{{ deploy_user }}"
+    mode: '0644'
+
+- name: Docker-Compose-Datei anpassen um die modifizierte Dockerfile zu verwenden
+  replace:
+    path: "{{ deploy_root }}/docker-compose-deploy.yml"
+    regexp: 'dockerfile: {{ deploy_root }}/docker/php/Dockerfile'
+    replace: 'dockerfile: {{ deploy_root }}/docker/php/Dockerfile-simple'
+
+- name: Erstelle composer.json für Docker-Build
+  copy:
+    dest: "{{ deploy_root }}/composer.json"
+    content: |
+      {
+        "name": "michaelschiemer/website",
+        "description": "Michael Schiemer Website",
+        "type": "project",
+        "require": {
+          "php": "^8.1"
+        },
+        "minimum-stability": "stable"
+      }
+    owner: "{{ deploy_user }}"
+    group: "{{ deploy_user }}"
+    mode: '0644'
+
+
+- name: Debug-Info für Docker Compose
+  debug:
+    msg: "Versuche, Container zu starten mit Docker Compose-Datei: {{ deploy_root }}/docker-compose-simple.yml"
+
+- name: Zeige Docker Images
+  shell: docker images
+  register: docker_images
+  ignore_errors: yes
+
+- name: Docker Images anzeigen
+  debug:
+    var: docker_images.stdout_lines
+
+- name: Zeige laufende Docker Container
+  shell: docker ps -a
+  register: docker_containers
+  ignore_errors: yes
+
+- name: Docker Container anzeigen
+  debug:
+    var: docker_containers.stdout_lines
+
+- name: Docker Compose Container stoppen
+  shell: |
+    cd {{ deploy_root }} && \
+    docker-compose -f {{ deploy_root }}/docker-compose-simple.yml -p michaelschiemer down --remove-orphans || true
+  args:
+    chdir: "{{ deploy_root }}"
+  environment:
+    COMPOSE_IGNORE_ORPHANS: "True"
+
+- name: Prüfe ob docker-compose-simple.yml existiert
+  stat:
+    path: "{{ deploy_root }}/docker-compose-simple.yml"
+  register: simple_compose_file
+
+- name: Anzeigen des Inhalts der docker-compose-simple.yml Datei
+  shell: cat {{ deploy_root }}/docker-compose-simple.yml
+  register: compose_content
+  when: simple_compose_file.stat.exists
+
+- name: Anzeigen des Inhalts der docker-compose-simple.yml Datei
+  debug:
+    var: compose_content.stdout_lines
+  when: compose_content is defined
+
+- name: Verzeichnisse in nginx Docker Verzeichnis anzeigen
+  shell: "ls -la {{ deploy_root }}/docker/nginx"
+  register: nginx_dir_content
+
+- name: Nginx Verzeichnisinhalt anzeigen
+  debug:
+    var: nginx_dir_content.stdout_lines
+
+- name: Stoppe alle Docker Container
+  shell: |
+    cd {{ deploy_root }} && \
+    docker-compose -f {{ deploy_root }}/docker-compose-simple.yml -p michaelschiemer down --remove-orphans
+  args:
+    chdir: "{{ deploy_root }}"
+  ignore_errors: yes
+  environment:
+    COMPOSE_IGNORE_ORPHANS: "True"
+
+- name: Bereinige Docker-Systemressourcen
+  shell: docker system prune -f
+  ignore_errors: yes
+
+- name: Docker Compose neu bauen und starten (vereinfachte Version)
+  shell: |
+    cd {{ deploy_root }} && \
+    export DOCKER_BUILDKIT=0 && \
+    docker-compose -f {{ deploy_root }}/docker-compose-simple.yml -p michaelschiemer up -d --build
+  args:
+    chdir: "{{ deploy_root }}"
+  ignore_errors: yes
+  environment:
+    COMPOSE_IGNORE_ORPHANS: "True"
+
+- name: Warte kurz bis Docker-Container gestartet sind
+  pause:
+    seconds: 5
+
+- name: Prüfe welche Prozesse an Port 80 gebunden sind
+  shell: |
+    netstat -tulpn | grep LISTEN | grep ':80' || echo "Kein Prozess an Port 80 gebunden"
+  register: port_80_check
+  ignore_errors: yes
+
+- name: Zeige Port 80 Bindung
+  debug:
+    var: port_80_check.stdout_lines
+
+- name: Prüfe Docker-Container Netzwerkeinstellungen
+  shell: |
+    docker inspect michaelschiemer-nginx-1 | grep -A 20 "NetworkSettings" || echo "Container nicht gefunden"
+  register: container_network
+  ignore_errors: yes
+
+- name: Zeige Container-Netzwerkeinstellungen
+  debug:
+    var: container_network.stdout_lines
+
+
+
+- name: PHP-Container für Composer starten
+  shell: docker-compose -f {{ deploy_root }}/docker-compose-simple.yml -p michaelschiemer up -d php
+  args:
+    chdir: "{{ deploy_root }}"
+
+- name: Kurze Wartezeit bis PHP-Container bereit
+  wait_for:
+    timeout: 5
+
+- name: Composer Abhängigkeiten installieren (deaktiviert)
+  debug:
+    msg: "Composer-Installation übersprungen - keine PHP-Anwendung vorhanden"
+  register: composer_result
+
+
+- name: Composer-Ergebnis anzeigen
+  debug:
+    var: composer_result.stdout_lines
+  when: composer_result.stdout is defined
+
+- name: Composer-Fehler anzeigen
+  debug:
+    var: composer_result.stderr_lines
+  when: composer_result.stderr is defined
diff --git a/x_ansible/roles/common/defaults/main.yml b/x_ansible/roles/common/defaults/main.yml
new file mode 100644
index 00000000..380db7dd
--- /dev/null
+++ b/x_ansible/roles/common/defaults/main.yml
@@ -0,0 +1,12 @@
+---
+# Standardwerte für die Common-Rolle
+
+# Verzeichnisse
+deploy_root: /var/www/michaelschiemer
+deploy_public: "{{ deploy_root }}/public"
+
+# Benutzer
+deploy_user: "{{ ansible_user | default('deploy') }}"
+
+# Domain
+app_domain: "localhost"
diff --git a/x_ansible/roles/common/tasks/main.yml b/x_ansible/roles/common/tasks/main.yml
new file mode 100644
index 00000000..2f6f9bbf
--- /dev/null
+++ b/x_ansible/roles/common/tasks/main.yml
@@ -0,0 +1,101 @@
+---
+# Common-Rolle für grundlegende Systemeinstellungen
+
+- name: Setze globale Variablen
+  set_fact:
+    deploy_root: "{{ deploy_root | default('/var/www/michaelschiemer') }}"
+    deploy_user: "{{ deploy_user | default(ansible_user) }}"
+    app_domain: "{{ app_domain | default('localhost') }}"
+  tags: [always]
+
+- name: Aktualisiere Paketindex
+  apt:
+    update_cache: yes
+    cache_valid_time: 3600
+  tags: [always]
+
+- name: Installiere grundlegende Pakete
+  apt:
+    name:
+      - sudo
+      - vim
+      - htop
+      - git
+      - zip
+      - unzip
+      - curl
+      - wget
+      - net-tools
+      - rsync
+      - python3-pip
+      - ufw
+      - fail2ban
+    state: present
+  tags: [system, packages]
+
+- name: Setze Zeitzone auf Europe/Berlin
+  timezone:
+    name: Europe/Berlin
+  tags: [system, timezone]
+
+# Benutzer und Berechtigungen
+- name: Stelle sicher, dass Deploy-Benutzer existiert
+  user:
+    name: "{{ deploy_user }}"
+    shell: /bin/bash
+    groups: sudo
+    append: yes
+    createhome: yes
+    state: present
+  when: deploy_user != 'root' and ansible_connection != 'local'
+  tags: [system, user]
+
+- name: Stelle sicher, dass SSH-Verzeichnis existiert
+  file:
+    path: "/home/{{ deploy_user }}/.ssh"
+    state: directory
+    owner: "{{ deploy_user }}"
+    group: "{{ deploy_user }}"
+    mode: '0700'
+  when: deploy_user != 'root' and ansible_connection != 'local'
+  tags: [system, user]
+
+- name: Konfiguriere passwordless sudo für deploy-Benutzer
+  lineinfile:
+    path: "/etc/sudoers.d/{{ deploy_user }}"
+    line: "{{ deploy_user }} ALL=(ALL) NOPASSWD: ALL"
+    state: present
+    create: yes
+    mode: '0440'
+    validate: 'visudo -cf %s'
+  become: true
+  when: deploy_user != 'root' and ansible_connection != 'local'
+  tags: [system, user]
+
+# Firewall
+- name: Öffne Ports in Firewall
+  ufw:
+    rule: allow
+    port: "{{ item }}"
+    proto: tcp
+  loop:
+    - '22'  # SSH
+    - '80'  # HTTP
+    - '443' # HTTPS
+  tags: [system, firewall]
+
+- name: Aktiviere Firewall
+  ufw:
+    state: enabled
+    policy: deny
+  tags: [system, firewall]
+
+# Verzeichnisse
+- name: Erstelle deploy_root-Verzeichnis
+  file:
+    path: "{{ deploy_root }}"
+    state: directory
+    owner: "{{ deploy_user }}"
+    group: "{{ deploy_user }}"
+    mode: '0755'
+  tags: [system, directories]
diff --git a/ansible/roles/console/tasks/main.yml b/x_ansible/roles/console/tasks/main.yml
similarity index 100%
rename from ansible/roles/console/tasks/main.yml
rename to x_ansible/roles/console/tasks/main.yml
diff --git a/ansible/roles/deploy/tasks/main.yml b/x_ansible/roles/deploy/tasks/main.yml
similarity index 96%
rename from ansible/roles/deploy/tasks/main.yml
rename to x_ansible/roles/deploy/tasks/main.yml
index 9d24ba21..b57e2c3d 100644
--- a/ansible/roles/deploy/tasks/main.yml
+++ b/x_ansible/roles/deploy/tasks/main.yml
@@ -1,14 +1,14 @@
-- name: Stoppe laufende Container
-  command: docker compose down
-  args:
-    chdir: "{{ playbook_dir }}/../"
-
-- name: Baue Images neu (ohne Cache)
-  command: docker compose build --no-cache
-  args:
-    chdir: "{{ playbook_dir }}/../"
-
-- name: Starte Container neu
-  command: docker compose up -d
-  args:
-    chdir: "{{ playbook_dir }}/../"
+- name: Stoppe laufende Container
+  command: docker compose down
+  args:
+    chdir: "{{ playbook_dir }}/../"
+
+- name: Baue Images neu (ohne Cache)
+  command: docker compose build --no-cache
+  args:
+    chdir: "{{ playbook_dir }}/../"
+
+- name: Starte Container neu
+  command: docker compose up -d
+  args:
+    chdir: "{{ playbook_dir }}/../"
diff --git a/x_ansible/roles/deploy/templates/.env.j2 b/x_ansible/roles/deploy/templates/.env.j2
new file mode 100644
index 00000000..68dec2e3
--- /dev/null
+++ b/x_ansible/roles/deploy/templates/.env.j2
@@ -0,0 +1,36 @@
+# Automatisch generierte .env-Datei
+# Generiert durch Ansible am {{ ansible_date_time.date }}
+
+COMPOSE_PROJECT_NAME={{ compose_project_name | default('michaelschiemer') }}
+
+# Allgemeine Einstellungen
+APP_NAME={{ app_name | default('michaelschiemer') }}
+APP_ENV={{ env_vars.APP_ENV | default('production') }}
+APP_DEBUG={{ env_vars.APP_DEBUG | default('false') }}
+APP_PORT={{ env_vars.APP_PORT | default(80) }}
+APP_SSL_PORT={{ env_vars.APP_SSL_PORT | default(443) }}
+
+# Server-Konfiguration
+APP_URL={{ 'https' if ssl_enabled | default(false) else 'http' }}://{{ app_domain }}
+
+# Datenbank-Einstellungen
+{% if lookup('vars', 'database_host', default=false) %}
+DB_CONNECTION=mysql
+DB_HOST={{ database_host }}
+DB_PORT=3306
+DB_DATABASE={{ database_name }}
+DB_USERNAME={{ database_user }}
+DB_PASSWORD={{ database_password | default('') }}
+{% endif %}
+
+# Redis-Konfiguration
+{% if lookup('vars', 'redis_host', default=false) %}
+REDIS_HOST={{ redis_host }}
+REDIS_PASSWORD={{ redis_password | default(null) }}
+REDIS_PORT={{ redis_port | default(6379) }}
+{% endif %}
+
+# Weitere Umgebungsspezifische Einstellungen
+{% for key, value in env_vars.items() if key not in ['APP_ENV', 'APP_DEBUG', 'APP_PORT', 'APP_SSL_PORT'] %}
+{{ key }}={{ value }}
+{% endfor %}
diff --git a/ansible/roles/docker/README.md b/x_ansible/roles/docker/README.md
similarity index 100%
rename from ansible/roles/docker/README.md
rename to x_ansible/roles/docker/README.md
diff --git a/x_ansible/roles/docker/defaults/main.yml b/x_ansible/roles/docker/defaults/main.yml
new file mode 100644
index 00000000..c8cb9317
--- /dev/null
+++ b/x_ansible/roles/docker/defaults/main.yml
@@ -0,0 +1,16 @@
+# Standardwerte für die Docker-Rolle
+
+# Docker-Version
+docker_version: "20.10"
+docker_compose_version: "2.24.5"
+
+# Docker-Einstellungen
+docker_install_compose: true
+docker_user: "{{ ansible_user | default('michael') }}"
+
+# Deployment-Verzeichnisse
+deploy_root: /var/www/michaelschiemer
+docker_compose_project_path: "{{ deploy_root }}"
+
+# Benutzer
+deploy_user: "{{ ansible_user | default('deploy') }}"
diff --git a/ansible/roles/docker/handlers/main.yml b/x_ansible/roles/docker/handlers/main.yml
similarity index 100%
rename from ansible/roles/docker/handlers/main.yml
rename to x_ansible/roles/docker/handlers/main.yml
diff --git a/x_ansible/roles/docker/tasks/main.yml b/x_ansible/roles/docker/tasks/main.yml
new file mode 100644
index 00000000..5347c3e9
--- /dev/null
+++ b/x_ansible/roles/docker/tasks/main.yml
@@ -0,0 +1,191 @@
+- name: Prüfe erforderliche Variablen
+  assert:
+    that:
+      - deploy_root is defined
+      - deploy_user is defined
+    fail_msg: "Erforderliche Variablen fehlen: deploy_root und/oder deploy_user nicht definiert"
+    success_msg: "Alle erforderlichen Variablen sind korrekt definiert"
+  tags: [always]
+
+- name: Docker-Abhängigkeiten installieren
+  apt:
+    name:
+      - apt-transport-https
+      - ca-certificates
+      - curl
+      - gnupg
+      - lsb-release
+    state: present
+    update_cache: yes
+---
+# Docker-Installation und -Konfiguration
+
+- name: Docker-Abhängigkeiten installieren
+  apt:
+    name:
+      - ca-certificates
+      - curl
+      - gnupg
+      - apt-transport-https
+      - software-properties-common
+    state: present
+    update_cache: yes
+---
+# Tasks für Docker-Installation
+
+- name: Docker-Abhängigkeiten installieren
+  apt:
+    name:
+      - apt-transport-https
+      - ca-certificates
+      - gnupg
+      - lsb-release
+    state: present
+
+- name: Docker GPG-Schlüssel hinzufügen
+  apt_key:
+    url: https://download.docker.com/linux/ubuntu/gpg
+    state: present
+
+- name: Docker Repository hinzufügen
+  apt_repository:
+    repo: deb [arch=amd64] https://download.docker.com/linux/ubuntu {{ ansible_distribution_release }} stable
+    state: present
+
+- name: Docker installieren
+  apt:
+    name:
+      - docker-ce
+      - docker-ce-cli
+      - containerd.io
+      - docker-compose-plugin
+    state: present
+    update_cache: yes
+
+- name: Docker-Gruppe erstellen
+  group:
+    name: docker
+    state: present
+
+- name: Benutzer zur Docker-Gruppe hinzufügen
+  user:
+    name: "{{ deploy_user }}"
+    groups: docker
+    append: yes
+
+- name: Docker-Dienst aktivieren und starten
+  service:
+    name: docker
+    state: started
+    enabled: yes
+
+- name: Prüfen, ob Docker funktioniert
+  shell: docker --version
+  register: docker_version
+  changed_when: false
+
+- name: Docker-Version anzeigen
+  debug:
+    var: docker_version.stdout
+- name: Docker GPG-Schlüssel hinzufügen
+  apt_key:
+    url: https://download.docker.com/linux/ubuntu/gpg
+    state: present
+
+- name: Docker-Repository hinzufügen
+  apt_repository:
+    repo: deb [arch=amd64] https://download.docker.com/linux/ubuntu {{ ansible_distribution_release }} stable
+    state: present
+
+- name: Docker installieren
+  apt:
+    name:
+      - docker-ce
+      - docker-ce-cli
+      - containerd.io
+    state: present
+    update_cache: yes
+
+- name: Docker-Gruppe erstellen
+  group:
+    name: docker
+    state: present
+
+- name: Deploy-Benutzer zur Docker-Gruppe hinzufügen
+  user:
+    name: "{{ deploy_user }}"
+    groups: docker
+    append: yes
+
+- name: Docker-Service aktivieren und starten
+  systemd:
+    name: docker
+    state: started
+    enabled: yes
+
+- name: Docker Compose herunterladen
+  get_url:
+    url: "https://github.com/docker/compose/releases/download/v{{ docker_compose_version }}/docker-compose-Linux-x86_64"
+    dest: /usr/local/bin/docker-compose
+    mode: '0755'
+
+- name: Docker-Verzeichnisse und -Dateien kopieren
+  copy:
+    src: "{{ playbook_dir }}/../docker/"
+    dest: "{{ deploy_root }}/docker/"
+    directory_mode: '0755'
+    mode: '0644'
+
+- name: Docker Compose-Datei kopieren
+  copy:
+    src: "{{ playbook_dir }}/../docker-compose.yml"
+    dest: "{{ deploy_root }}/docker-compose.yml"
+    mode: '0644'
+- name: Docker GPG-Schlüssel hinzufügen
+  apt_key:
+    url: https://download.docker.com/linux/{{ ansible_distribution | lower }}/gpg
+    state: present
+
+- name: Docker Repository hinzufügen
+  apt_repository:
+    repo: "deb [arch=amd64] https://download.docker.com/linux/{{ ansible_distribution | lower }} {{ ansible_distribution_release }} stable"
+    state: present
+
+- name: Docker Engine installieren
+  apt:
+    name:
+      - docker-ce
+      - docker-ce-cli
+      - containerd.io
+      - docker-compose-plugin
+    state: present
+    update_cache: yes
+
+- name: Docker Compose installieren (V1 als Fallback)
+  get_url:
+    url: "https://github.com/docker/compose/releases/download/v{{ docker_compose_version }}/docker-compose-linux-x86_64"
+    dest: /usr/local/bin/docker-compose
+    mode: '0755'
+
+- name: Benutzer zur Docker-Gruppe hinzufügen
+  user:
+    name: "{{ ansible_user }}"
+    groups: docker
+    append: yes
+
+- name: Docker-Service starten und aktivieren
+  service:
+    name: docker
+    state: started
+    enabled: yes
+  notify: restart docker
+
+
+- name: Starte Docker-Container via Compose
+  community.docker.docker_compose_v2:
+    #project_src: "{{ playbook_dir | dirname }}/../"   # ggf. anpassen auf deinen Compose-Pfad!
+    project_src: "{{ deploy_root }}"
+    build: always
+    recreate: always
+  when: false
+
diff --git a/x_ansible/roles/nginx/defaults/main.yml b/x_ansible/roles/nginx/defaults/main.yml
new file mode 100644
index 00000000..7cf8d1f8
--- /dev/null
+++ b/x_ansible/roles/nginx/defaults/main.yml
@@ -0,0 +1,22 @@
+---
+# Standardwerte für die Nginx-Rolle
+
+# Nginx-Konfiguration
+nginx_worker_processes: auto
+nginx_worker_connections: 1024
+
+# Nginx-Verzeichnisse
+nginx_target_dir: "{{ deploy_root }}/docker/nginx"
+
+# SSL-Verzeichnisse
+nginx_ssl_dest_dir: "{{ deploy_root }}/ssl"
+
+# Deployment-Verzeichnisse
+deploy_root: /var/www/michaelschiemer
+deploy_public: "{{ deploy_root }}/public"
+
+# Benutzer
+deploy_user: "{{ ansible_user | default('deploy') }}"
+
+# Domain
+app_domain: "localhost"
diff --git a/ansible/roles/nginx/templates/nginx.conf.j2 b/x_ansible/roles/nginx/files/docker-entrypoint.sh
similarity index 100%
rename from ansible/roles/nginx/templates/nginx.conf.j2
rename to x_ansible/roles/nginx/files/docker-entrypoint.sh
diff --git a/x_ansible/roles/nginx/handlers/main.yml b/x_ansible/roles/nginx/handlers/main.yml
new file mode 100644
index 00000000..a5eb9d92
--- /dev/null
+++ b/x_ansible/roles/nginx/handlers/main.yml
@@ -0,0 +1,14 @@
+- name: reload nginx
+  ansible.builtin.shell: |
+    # Versuche unterschiedliche Container-Namen und Methoden
+    CONTAINER_ID=$(docker ps -q --filter name=michaelschiemer_nginx || docker ps -q --filter name=nginx)
+    if [ -n "$CONTAINER_ID" ]; then
+      docker exec $CONTAINER_ID nginx -s reload || true
+    else
+      # Wenn Container nicht gefunden, versuche Neustart über Docker Compose
+      cd {{ deploy_root }} && \
+      docker-compose -f {{ deploy_root }}/docker-compose-simple.yml restart nginx || true
+    fi
+  args:
+    executable: /bin/bash
+  ignore_errors: yes
diff --git a/x_ansible/roles/nginx/tasks/main.yml b/x_ansible/roles/nginx/tasks/main.yml
new file mode 100644
index 00000000..2cf82467
--- /dev/null
+++ b/x_ansible/roles/nginx/tasks/main.yml
@@ -0,0 +1,299 @@
+---
+- name: Stelle sicher, dass Nginx-Verzeichnisse existieren
+  ansible.builtin.file:
+    path: "{{ nginx_target_dir }}"
+    state: directory
+    recurse: yes
+    mode: '0755'
+
+- name: Kopiere Nginx-Konfigurationsdateien
+  ansible.builtin.copy:
+    src: "{{ playbook_dir }}/../docker/nginx/{{ item }}"
+    dest: "{{ nginx_target_dir }}/{{ item }}"
+    mode: '0644'
+  loop:
+    - nginx.conf
+    - default.conf
+  notify: reload nginx
+
+- name: Erstelle nginx.conf
+  ansible.builtin.copy:
+    dest: "{{ nginx_target_dir }}/nginx.conf"
+    content: |
+      user  nginx;
+      worker_processes  {{ nginx_worker_processes }};
+
+      error_log  /var/log/nginx/error.log warn;
+      pid        /var/run/nginx.pid;
+
+      events {
+          worker_connections  {{ nginx_worker_connections }};
+      }
+
+      http {
+          include       /etc/nginx/mime.types;
+          default_type  application/octet-stream;
+
+          log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
+                            '$status $body_bytes_sent "$http_referer" '
+                            '"$http_user_agent" "$http_x_forwarded_for"';
+
+          access_log  /var/log/nginx/access.log  main;
+
+          sendfile        on;
+          keepalive_timeout  65;
+
+          include /etc/nginx/conf.d/*.conf;
+      }
+    mode: '0644'
+
+- name: Überprüfe ob default.conf ein Verzeichnis ist
+  stat:
+    path: "{{ nginx_target_dir }}/default.conf"
+  register: default_conf_stat
+
+- name: Entferne default.conf Verzeichnis falls es existiert
+  file:
+    path: "{{ nginx_target_dir }}/default.conf"
+    state: absent
+  when: default_conf_stat.stat.exists and default_conf_stat.stat.isdir
+
+- name: Erstelle default.conf
+  ansible.builtin.copy:
+    dest: "{{ nginx_target_dir }}/default.conf"
+    content: |
+      server {
+          listen 80;
+          listen [::]:80;
+          server_name {{ app_domain }};
+
+          # Weiterleitung auf HTTPS, wenn verfügbar
+          # location / {
+          #     return 301 https://$host$request_uri;
+          # }
+
+          root /var/www/html/public;
+          index index.php index.html;
+
+          location / {
+              try_files $uri $uri/ /index.php?$query_string;
+          }
+
+          location ~ \.php$ {
+              fastcgi_pass php:9000;
+              fastcgi_index index.php;
+              fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
+              include fastcgi_params;
+          }
+
+          # Vite Dev Server Proxy (deaktiviert)
+          # include /etc/nginx/vite-proxy.inc;
+      }
+
+      # HTTPS Server
+      server {
+          listen 443 ssl;
+          listen [::]:443 ssl;
+          server_name {{ app_domain }};
+
+          ssl_certificate     /etc/nginx/ssl/fullchain.pem;
+          ssl_certificate_key /etc/nginx/ssl/privkey.pem;
+          ssl_protocols       TLSv1.2 TLSv1.3;
+          ssl_ciphers         HIGH:!aNULL:!MD5;
+
+          root /var/www/html/public;
+          index index.php index.html;
+
+          location / {
+              try_files $uri $uri/ /index.php?$query_string;
+          }
+
+          location ~ \.php$ {
+              fastcgi_pass php:9000;
+              fastcgi_index index.php;
+              fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
+              include fastcgi_params;
+          }
+
+          # Vite Dev Server Proxy (deaktiviert)
+          # include /etc/nginx/vite-proxy.inc;
+      }
+    mode: '0644'
+
+- name: Prüfe ob vite-proxy.inc existiert
+  stat:
+    path: "{{ nginx_vite_proxy_src }}"
+  register: vite_proxy_exists
+  delegate_to: localhost
+  become: false
+---
+# Tasks für Nginx-Konfiguration
+
+- name: Nginx-Konfigurationsverzeichnis erstellen
+  file:
+    path: "{{ deploy_root }}/docker/nginx"
+    state: directory
+    owner: "{{ deploy_user }}"
+    group: "{{ deploy_user }}"
+    mode: '0755'
+
+- name: Erstelle Nginx-Hauptkonfiguration
+  copy:
+    dest: "{{ deploy_root }}/docker/nginx/nginx.conf"
+    content: |
+      user  nginx;
+      worker_processes  {{ nginx_worker_processes }};
+
+      error_log  /var/log/nginx/error.log warn;
+      pid        /var/run/nginx.pid;
+
+      events {
+          worker_connections  {{ nginx_worker_connections }};
+      }
+
+      http {
+          include       /etc/nginx/mime.types;
+          default_type  application/octet-stream;
+
+          log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
+                          '$status $body_bytes_sent "$http_referer" '
+                          '"$http_user_agent" "$http_x_forwarded_for"';
+
+          access_log  /var/log/nginx/access.log  main;
+
+          sendfile        on;
+          #tcp_nopush     on;
+
+          keepalive_timeout  65;
+
+          #gzip  on;
+
+          include /etc/nginx/conf.d/*.conf;
+      }
+    owner: "{{ deploy_user }}"
+    group: "{{ deploy_user }}"
+    mode: '0644'
+  notify: reload nginx
+
+- name: Erstelle Nginx-Default-Konfiguration
+  copy:
+    dest: "{{ deploy_root }}/docker/nginx/default.conf"
+    content: |
+      server {
+          listen 80;
+          server_name {{ app_domain }} localhost;
+          root /var/www/html/public;
+
+          index index.php index.html;
+
+          location / {
+              try_files $uri $uri/ /index.php?$query_string;
+          }
+
+          location ~ \.php$ {
+              fastcgi_pass php:9000;
+              fastcgi_index index.php;
+              fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
+              include fastcgi_params;
+          }
+
+          location ~ /\.ht {
+              deny all;
+          }
+      }
+    owner: "{{ deploy_user }}"
+    group: "{{ deploy_user }}"
+    mode: '0644'
+  notify: reload nginx
+- name: Kopiere richtige vite-proxy.inc je nach Umgebung (falls vorhanden)
+  ansible.builtin.copy:
+    src: "{{ nginx_vite_proxy_src }}"
+    dest: "{{ nginx_target_dir }}/vite-proxy.inc"
+    mode: '0644'
+  notify: reload nginx
+  when: vite_proxy_exists.stat.exists
+
+- name: Überprüfe ob vite-proxy.inc ein Verzeichnis ist
+  stat:
+    path: "{{ nginx_target_dir }}/vite-proxy.inc"
+  register: vite_proxy_stat
+
+- name: Entferne vite-proxy.inc Verzeichnis falls es existiert
+  file:
+    path: "{{ nginx_target_dir }}/vite-proxy.inc"
+    state: absent
+  when: vite_proxy_stat.stat.exists and vite_proxy_stat.stat.isdir
+
+- name: Erstelle Standard vite-proxy.inc Datei (falls nicht vorhanden)
+  ansible.builtin.copy:
+    dest: "{{ nginx_target_dir }}/vite-proxy.inc"
+    content: |
+      # Standard Vite Proxy Konfiguration
+      location /@vite/ {
+          proxy_pass http://localhost:5173/;
+          proxy_set_header Host $host;
+      }
+
+      location /@fs/ {
+          proxy_pass http://localhost:5173/;
+          proxy_set_header Host $host;
+      }
+
+      location /node_modules/ {
+          proxy_pass http://localhost:5173/node_modules/;
+          proxy_set_header Host $host;
+      }
+    mode: '0644'
+  notify: reload nginx
+  when: not vite_proxy_exists.stat.exists
+
+- name: Überprüfe ob docker-entrypoint.sh ein Verzeichnis ist
+  stat:
+    path: "{{ nginx_target_dir }}/docker-entrypoint.sh"
+  register: entrypoint_stat
+
+- name: Entferne docker-entrypoint.sh Verzeichnis falls es existiert
+  file:
+    path: "{{ nginx_target_dir }}/docker-entrypoint.sh"
+    state: absent
+  when: entrypoint_stat.stat.exists and entrypoint_stat.stat.isdir
+
+- name: Erstelle docker-entrypoint Skript
+  ansible.builtin.copy:
+    dest: "{{ nginx_target_dir }}/docker-entrypoint.sh"
+    content: |
+      #!/bin/sh
+
+      # Überprüfe SSL-Zertifikate und erstelle selbstsignierte, wenn keine vorhanden sind
+      if [ ! -f /etc/nginx/ssl/fullchain.pem ] || [ ! -f /etc/nginx/ssl/privkey.pem ]; then
+          echo "Keine SSL-Zertifikate gefunden, erstelle selbstsignierte Zertifikate..."
+          mkdir -p /etc/nginx/ssl
+          openssl req -x509 -nodes -days 365 -newkey rsa:2048 \
+              -keyout /etc/nginx/ssl/privkey.pem \
+              -out /etc/nginx/ssl/fullchain.pem \
+              -subj "/CN=localhost"
+      fi
+
+      # Starte Nginx im Vordergrund
+      echo "Starte Nginx..."
+      exec nginx -g 'daemon off;'
+    mode: '0755'
+
+- name: Baue und starte Nginx-Container (optional, wenn Compose separat genutzt wird, dann hier nicht nötig)
+  ansible.builtin.shell: |
+    export DOCKER_BUILDKIT=0
+    docker-compose -f "{{ deploy_root }}/docker-compose-simple.yml" up -d --build nginx
+  args:
+    chdir: "{{ deploy_root }}"
+    executable: /bin/bash
+  when: nginx_target_dir is defined and deploy_root is defined
+  register: nginx_compose_result
+  ignore_errors: true
+  environment:
+    COMPOSE_IGNORE_ORPHANS: "True"
+    PATH: "/usr/local/bin:/usr/bin:/bin"
+
+- name: Zeige Compose-Resultat
+  ansible.builtin.debug:
+    var: nginx_compose_result.stdout_lines
+  when: nginx_compose_result is defined
diff --git a/x_ansible/roles/nginx/templates/default.conf.j2 b/x_ansible/roles/nginx/templates/default.conf.j2
new file mode 100644
index 00000000..e69de29b
diff --git a/x_ansible/roles/nginx/templates/nginx.conf.j2 b/x_ansible/roles/nginx/templates/nginx.conf.j2
new file mode 100644
index 00000000..e69de29b
diff --git a/x_ansible/roles/php/defaults/main.yml b/x_ansible/roles/php/defaults/main.yml
new file mode 100644
index 00000000..8a53c067
--- /dev/null
+++ b/x_ansible/roles/php/defaults/main.yml
@@ -0,0 +1,23 @@
+---
+# Standardwerte für die PHP-Rolle
+---
+# Standardwerte für die PHP-Rolle
+
+# PHP-Version
+php_version: "8.1"
+
+# PHP-Erweiterungen
+php_extensions:
+  - zip
+  - pdo
+  - pdo_mysql
+  - opcache
+# PHP-Version
+php_version: "8.4"
+
+# Deployment-Verzeichnisse
+deploy_root: /var/www/michaelschiemer
+deploy_public: "{{ deploy_root }}/public"
+
+# Benutzer
+deploy_user: "{{ ansible_user | default('deploy') }}"
diff --git a/x_ansible/roles/php/tasks/main.yml b/x_ansible/roles/php/tasks/main.yml
new file mode 100644
index 00000000..61ee50e2
--- /dev/null
+++ b/x_ansible/roles/php/tasks/main.yml
@@ -0,0 +1,33 @@
+---
+# PHP Installation und Konfiguration
+
+- name: Stelle sicher, dass das PHP-Docker-Verzeichnis existiert
+  file:
+    path: "{{ deploy_root }}/docker/php"
+    state: directory
+    owner: "{{ deploy_user }}"
+    group: "{{ deploy_user }}"
+    mode: '0755'
+
+- name: Erstelle einfache PHP-Dockerfile
+  copy:
+    dest: "{{ deploy_root }}/docker/php/Dockerfile-simple"
+    content: |
+      FROM php:8.1-fpm
+
+      RUN apt-get update && apt-get install -y \
+          git \
+          unzip \
+          libzip-dev \
+          zip \
+          && docker-php-ext-install zip pdo pdo_mysql \
+          && docker-php-ext-install opcache \
+          && apt-get clean \
+          && rm -rf /var/lib/apt/lists/*
+
+      WORKDIR /var/www/html
+
+      CMD ["php-fpm"]
+    owner: "{{ deploy_user }}"
+    group: "{{ deploy_user }}"
+    mode: '0644'
diff --git a/x_ansible/roles/redis/defaults/main.yml b/x_ansible/roles/redis/defaults/main.yml
new file mode 100644
index 00000000..10bff3fb
--- /dev/null
+++ b/x_ansible/roles/redis/defaults/main.yml
@@ -0,0 +1,19 @@
+---
+# Standardwerte für die Redis-Rolle
+---
+# Standardwerte für die Redis-Rolle
+
+# Redis-Speicherlimit
+redis_maxmemory: "128mb"
+
+# Redis-Port
+redis_port: 6379
+# Deployment-Verzeichnisse
+deploy_root: /var/www/michaelschiemer
+
+# Benutzer
+deploy_user: "{{ ansible_user | default('deploy') }}"
+
+# Redis-Konfiguration
+redis_maxmemory: "256mb"
+redis_port: 6379
diff --git a/x_ansible/roles/redis/tasks/main.yml b/x_ansible/roles/redis/tasks/main.yml
new file mode 100644
index 00000000..d3827b15
--- /dev/null
+++ b/x_ansible/roles/redis/tasks/main.yml
@@ -0,0 +1,72 @@
+---
+# Redis Installation und Konfiguration
+
+- name: Stelle sicher, dass das Redis-Docker-Verzeichnis existiert
+  file:
+    path: "{{ deploy_root }}/docker/redis"
+    state: directory
+    owner: "{{ deploy_user }}"
+    group: "{{ deploy_user }}"
+    mode: '0755'
+
+- name: Erstelle Redis-Konfiguration
+  copy:
+    dest: "{{ deploy_root }}/docker/redis/redis.conf"
+    content: |
+      bind 0.0.0.0
+      protected-mode yes
+      port 6379
+      tcp-backlog 511
+      timeout 0
+      tcp-keepalive 300
+      daemonize no
+      supervised no
+      pidfile /var/run/redis_6379.pid
+      loglevel notice
+      logfile ""
+      databases 16
+      save 900 1
+      save 300 10
+      save 60 10000
+      stop-writes-on-bgsave-error yes
+      rdbcompression yes
+      rdbchecksum yes
+      dbfilename dump.rdb
+      dir ./
+      slave-serve-stale-data yes
+      slave-read-only yes
+      repl-diskless-sync no
+      repl-diskless-sync-delay 5
+      repl-disable-tcp-nodelay no
+      slave-priority 100
+      maxmemory {{ redis_maxmemory | default('128mb') }}
+      maxmemory-policy allkeys-lru
+      appendonly no
+      appendfilename "appendonly.aof"
+      appendfsync everysec
+      no-appendfsync-on-rewrite no
+      auto-aof-rewrite-percentage 100
+      auto-aof-rewrite-min-size 64mb
+      aof-load-truncated yes
+      lua-time-limit 5000
+      slowlog-log-slower-than 10000
+      slowlog-max-len 128
+      latency-monitor-threshold 0
+      notify-keyspace-events ""
+      hash-max-ziplist-entries 512
+      hash-max-ziplist-value 64
+      list-max-ziplist-entries 512
+      list-max-ziplist-value 64
+      set-max-intset-entries 512
+      zset-max-ziplist-entries 128
+      zset-max-ziplist-value 64
+      hll-sparse-max-bytes 3000
+      activerehashing yes
+      client-output-buffer-limit normal 0 0 0
+      client-output-buffer-limit slave 256mb 64mb 60
+      client-output-buffer-limit pubsub 32mb 8mb 60
+      hz 10
+      aof-rewrite-incremental-fsync yes
+    owner: "{{ deploy_user }}"
+    group: "{{ deploy_user }}"
+    mode: '0644'
diff --git a/x_ansible/roles/setup/defaults/main.yml b/x_ansible/roles/setup/defaults/main.yml
new file mode 100644
index 00000000..336b8bd0
--- /dev/null
+++ b/x_ansible/roles/setup/defaults/main.yml
@@ -0,0 +1,12 @@
+---
+# Standardwerte für die Setup-Rolle
+
+# Verzeichnisse
+deploy_root: /var/www/michaelschiemer
+deploy_public: "{{ deploy_root }}/public"
+
+# Benutzer
+deploy_user: "{{ ansible_user | default('deploy') }}"
+
+# Domain
+app_domain: "localhost"
diff --git a/ansible/roles/setup/handlers/main.yml b/x_ansible/roles/setup/handlers/main.yml
similarity index 100%
rename from ansible/roles/setup/handlers/main.yml
rename to x_ansible/roles/setup/handlers/main.yml
diff --git a/ansible/roles/setup/tasks/main.yml b/x_ansible/roles/setup/tasks/main.yml
similarity index 95%
rename from ansible/roles/setup/tasks/main.yml
rename to x_ansible/roles/setup/tasks/main.yml
index 34d36c99..37f87537 100644
--- a/ansible/roles/setup/tasks/main.yml
+++ b/x_ansible/roles/setup/tasks/main.yml
@@ -1,47 +1,47 @@
-- name: Docker installieren
-  apt:
-    name:
-      - docker.io
-      - docker-compose
-    state: present
-    update_cache: yes
-
-- name: Certbot + Plugin installieren
-  apt:
-    name:
-      - certbot
-      - python3-certbot-nginx
-    state: present
-    update_cache: yes
-
-- name: Challenge-Verzeichnis für Let's Encrypt anlegen
-  file:
-    path: /var/www/html/.well-known/acme-challenge
-    state: directory
-    owner: www-data
-    group: www-data
-    mode: '0755'
-    recurse: yes
-
-- name: Füge Let's Encrypt Challenge-Pfad in den Nginx-Vhost ein
-  blockinfile:
-    path: /etc/nginx/sites-available/default
-    marker: "# {mark} ANSIBLE LETSENCRYPT"
-    insertafter: "^\\s*server\\s*{"
-    block: |
-      location ^~ /.well-known/acme-challenge/ {
-          root /var/www/html;
-          allow all;
-          default_type "text/plain";
-      }
-  notify: Reload nginx
-
-
-
-- name: Let's Encrypt Zertifikat anfordern
-  command: >
-    certbot --nginx -n --agree-tos --redirect
-    -m kontakt@michaelschiemer.de
-    -d test.michaelschiemer.de
-  args:
-    creates: /etc/letsencrypt/live/test.michaelschiemer.de/fullchain.pem
+- name: Docker installieren
+  apt:
+    name:
+      - docker.io
+      - docker-compose
+    state: present
+    update_cache: yes
+
+- name: Certbot + Plugin installieren
+  apt:
+    name:
+      - certbot
+      - python3-certbot-nginx
+    state: present
+    update_cache: yes
+
+- name: Challenge-Verzeichnis für Let's Encrypt anlegen
+  file:
+    path: /var/www/html/.well-known/acme-challenge
+    state: directory
+    owner: www-data
+    group: www-data
+    mode: '0755'
+    recurse: yes
+
+- name: Füge Let's Encrypt Challenge-Pfad in den Nginx-Vhost ein
+  blockinfile:
+    path: /etc/nginx/sites-available/default
+    marker: "# {mark} ANSIBLE LETSENCRYPT"
+    insertafter: "^\\s*server\\s*{"
+    block: |
+      location ^~ /.well-known/acme-challenge/ {
+          root /var/www/html;
+          allow all;
+          default_type "text/plain";
+      }
+  notify: Reload nginx
+
+
+
+- name: Let's Encrypt Zertifikat anfordern
+  command: >
+    certbot --nginx -n --agree-tos --redirect
+    -m kontakt@michaelschiemer.de
+    -d test.michaelschiemer.de
+  args:
+    creates: /etc/letsencrypt/live/test.michaelschiemer.de/fullchain.pem
diff --git a/ansible/roles/system_update/tasks/main.yml b/x_ansible/roles/system_update/tasks/main.yml
similarity index 100%
rename from ansible/roles/system_update/tasks/main.yml
rename to x_ansible/roles/system_update/tasks/main.yml
diff --git a/ansible/roles/webserver/tasks/main.yml b/x_ansible/roles/webserver/tasks/main.yml
similarity index 100%
rename from ansible/roles/webserver/tasks/main.yml
rename to x_ansible/roles/webserver/tasks/main.yml
diff --git a/ansible.cfg b/x_ansible/root_ansible.cfg
similarity index 96%
rename from ansible.cfg
rename to x_ansible/root_ansible.cfg
index 9c3c58f5..bd91d615 100644
--- a/ansible.cfg
+++ b/x_ansible/root_ansible.cfg
@@ -2,6 +2,7 @@
 #inventory = ./ansible/inventory.ini
 inventory = ./ansible/inventory/hosts.ini
 roles_path = ./ansible/roles
+playbook_dir = ./ansible
 remote_tmp = ~/.ansible/tmp
 forks = 5
 timeout = 10
diff --git a/x_ansible/setup.sh b/x_ansible/setup.sh
new file mode 100755
index 00000000..c1d56863
--- /dev/null
+++ b/x_ansible/setup.sh
@@ -0,0 +1,43 @@
+#!/bin/bash
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+
+echo "=== Ansible-Setup für michaelschiemer.de ==="
+echo "Dieses Script vereinfacht die Ausführung der Ansible-Playbooks."
+
+if [ "$#" -lt 1 ]; then
+    echo "Verwendung: $0 [setup|deploy] [Zielumgebung]"
+    echo "Beispiel: $0 setup staging"
+    echo "Beispiel: $0 deploy production"
+    exit 1
+fi
+
+ACTION=$1
+ENVIRONMENT=${2:-staging}  # Standard ist staging
+
+echo "Aktion: $ACTION"
+echo "Zielumgebung: $ENVIRONMENT"
+echo ""
+
+# Wechsle in das Ansible-Verzeichnis
+cd "$SCRIPT_DIR"
+
+if [ "$ACTION" == "setup" ]; then
+    echo "Führe Server-Setup für $ENVIRONMENT aus..."
+    ansible-playbook -i inventory/hosts.ini setup.yml --limit $ENVIRONMENT -v
+    exit_code=$?
+elif [ "$ACTION" == "deploy" ]; then
+    echo "Führe Deployment für $ENVIRONMENT aus..."
+    ansible-playbook -i inventory/hosts.ini playbooks/deploy.yml --limit $ENVIRONMENT -v
+    exit_code=$?
+else
+    echo "Unbekannte Aktion: $ACTION"
+    echo "Erlaubte Aktionen: setup, deploy"
+    exit 1
+fi
+
+if [ $exit_code -eq 0 ]; then
+    echo "\n✅ Ansible-Ausführung erfolgreich abgeschlossen!"
+else
+    echo "\n❌ Ansible-Ausführung fehlgeschlagen mit Fehlercode $exit_code"
+fi
diff --git a/x_ansible/setup.yml b/x_ansible/setup.yml
new file mode 100644
index 00000000..564545c0
--- /dev/null
+++ b/x_ansible/setup.yml
@@ -0,0 +1,134 @@
+---
+# Basis-Setup für Server
+# Dieses Playbook richtet grundlegende Komponenten auf den Zielsystemen ein
+
+- name: Basis-Setup für alle Zielsysteme
+  hosts: all
+  become: true
+  gather_facts: true
+
+  pre_tasks:
+    - name: Aktualisiere den Paket-Cache
+      apt:
+        update_cache: yes
+        cache_valid_time: 3600
+      when: ansible_os_family == "Debian"
+      tags: [system, update]
+---
+# Basis-Setup für Server
+# Dieses Playbook richtet grundlegende Komponenten auf den Zielsystemen ein
+
+- name: Basis-Setup für alle Zielsysteme
+  hosts: all
+  become: true
+  gather_facts: true
+
+  pre_tasks:
+    - name: Debug Variablen
+      debug:
+        msg:
+          - "Host: {{ inventory_hostname }}"
+          - "Umgebung: {{ environment | default('undefiniert') }}"
+          - "deploy_root: {{ deploy_root | default('undefiniert') }}"
+          - "deploy_user: {{ deploy_user | default('undefiniert') }}"
+      tags: [always, debug]
+
+  roles:
+    - common
+    - docker
+    - webserver
+
+  post_tasks:
+    - name: Zeige Erfolgsmeldung
+      debug:
+        msg: "Basiseinrichtung auf {{ inventory_hostname }} abgeschlossen"
+      tags: [always]
+    - name: Installiere grundlegende Pakete
+      apt:
+        name:
+          - curl
+          - wget
+          - vim
+          - htop
+          - git
+          - zip
+          - unzip
+          - python3-pip
+        state: present
+      when: ansible_os_family == "Debian"
+      tags: [system, packages]
+
+  roles:
+    - common
+    - docker
+    - webserver
+---
+- name: Basis-Setup für alle Zielsysteme
+  hosts: web
+  become: true
+  gather_facts: true
+
+  pre_tasks:
+    - name: Überprüfe Serververbindung
+      ping:
+      tags: [always, check]
+
+    - name: Zeige Server-Informationen
+      debug:
+        msg: "Verbunden mit {{ inventory_hostname }} ({{ ansible_host | default('IP unbekannt') }})"
+      tags: [always, check]
+
+  roles:
+    - common
+    - docker
+
+  post_tasks:
+    - name: Stelle sicher, dass Zielverzeichnisse existieren
+      file:
+        path: "{{ item }}"
+        state: directory
+        owner: "{{ deploy_user }}"
+        group: "{{ deploy_user }}"
+        mode: '0755'
+      loop:
+        - "{{ deploy_root }}"
+        - "{{ deploy_root }}/public"
+        - "{{ deploy_root }}/ssl"
+        - "{{ deploy_root }}/src"
+        - "{{ deploy_root }}/docker"
+        - "{{ deploy_root }}/docker/nginx"
+        - "{{ deploy_root }}/docker/php"
+      tags: [setup, folders]
+
+    - name: Erstelle Test-HTML-Datei
+      copy:
+        dest: "{{ deploy_root }}/public/index.html"
+        content: |
+          <!DOCTYPE html>
+          <html>
+          <head>
+              <title>Server Setup erfolgreich</title>
+              <style>
+                  body { font-family: Arial, sans-serif; margin: 40px; }
+                  h1 { color: #3273dc; }
+                  .container { max-width: 800px; margin: 0 auto; padding: 20px; border: 1px solid #eee; border-radius: 5px; }
+              </style>
+          </head>
+          <body>
+              <div class="container">
+                  <h1>Server-Setup erfolgreich!</h1>
+                  <p>Diese Seite bestätigt, dass die grundlegende Servereinrichtung abgeschlossen ist.</p>
+                  <p>Als nächstes können Sie das Deployment ausführen mit:</p>
+                  <pre>./ansible/deploy.sh {{ environment | default('staging') }}</pre>
+              </div>
+          </body>
+          </html>
+        mode: '0644'
+        owner: "{{ deploy_user }}"
+        group: "{{ deploy_user }}"
+      tags: [setup, test]
+  post_tasks:
+    - name: Zeige Erfolgsmeldung
+      debug:
+        msg: "Basiseinrichtung auf {{ inventory_hostname }} abgeschlossen"
+      tags: [always]