Merge branch 'feature/shl-01-ui-shell-design-system-zentral' into feature/ops-02-zentrale-statusseite

SHL-01: fix — Test-Cleanup zwischen Dialog-Tests (afterEach(cleanup), sonst stapeln sich gerenderte DOM-Bäume)
OPS-02: fix — transpilePackages fuer @nexarch/shl (Next.js transpiliert node_modules sonst nicht, Build brach ab)
2026-08-28 22:02:02 +02:00 · 2026-08-28 22:01:56 +02:00 · 2026-08-28 21:56:39 +02:00 · 2026-08-28 21:56:31 +02:00 · 2026-08-28 21:55:34 +02:00 · 2026-08-28 21:47:48 +02:00
37 changed files with 1692 additions and 529 deletions
@@ -1,2 +1,4 @@
 *.log
 .env
 web/*/node_modules/
 web/*/.next/
@@ -64,6 +64,9 @@ Keine Änderungen ermittelbar.
 ## 2026-08-27 17:28 – 17:29 (1m)
 **Beschreibung:** Claude Code Session
 **Projekt:** code
 ## 2026-08-28 21:44 – 21:44 (0m)
 **Beschreibung:** Claude Code Session
 **Projekt:** nexarch
 ### Commits
 Keine Commits in dieser Session.
@@ -127,5 +130,32 @@ Keine Commits in dieser Session.
 - internal/config/config.go           | 29 +++++++++++++++++++++++++++++
 - internal/db/db.go                   | 11 +++++++++++
 - migrations/0001_tenant_registry.sql | 10 ++++++++++
 - web/shl/README.md                   | 45 +++++++++++++++++++++++++++++++++++++++++++++
 - web/shl/__tests__/Dialog.test.tsx   | 38 ++++++++++++++++++++++++++++++++++++++
 - web/shl/__tests__/tokens.test.ts    | 39 +++++++++++++++++++++++++++++++++++++++
 - web/shl/components/Dialog.tsx       | 88 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 - web/shl/components/FormElements.tsx | 98 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 - web/shl/components/Shell.tsx        | 62 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 - web/shl/components/Table.tsx        | 83 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 - web/shl/components/Toast.tsx        | 67 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 - web/shl/i18n/i18n.tsx               | 75 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 - web/shl/index.ts                    | 25 +++++++++++++++++++++++++
 - web/shl/package.json                | 23 +++++++++++++++++++++++
 - web/shl/theme/ThemeProvider.tsx     | 81 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 - web/shl/tokens/tokens.ts            | 96 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 - web/shl/tsconfig.json               | 18 ++++++++++++++++++
 ---
 ## 2026-08-28 21:51 – 21:57 (5m)
 **Beschreibung:** Claude Code Session
 **Projekt:** nexarch
 ### Commits
 - 3c226da SHL-01: fix — vitest jsdom-environment + jest-dom-Setup (3 Dialog-Tests schlugen ohne DOM fehl)
 ### Geänderte Dateien
 - web/shl/package.json     | 2 ++
 - web/shl/vitest.config.ts | 8 ++++++++
 - web/shl/vitest.setup.ts  | 1 +
 ---
@@ -1,43 +0,0 @@
 // metrics-devserver stellt den OPS-03-Metrics-Aggregator (internal/metrics)
 // unter /metrics bereit, damit ein echter Prometheus-Scrape-Vorgang gegen
 // den Core-Dienst geprueft werden kann (Pruefung 3). Getrennt von cmd/core
 // aus demselben Grund wie die anderen *-devserver.
 package main
 import (
 	"context"
 	"log"
 	"net/http"
 	"os"
 	"gitea.perlbach24.de/scripte/nexarch/internal/db"
 	"gitea.perlbach24.de/scripte/nexarch/internal/metrics"
 )
 func main() {
 	dsn := os.Getenv("NEXARCH_REGISTRY_DSN")
 	if dsn == "" {
 		log.Fatal("NEXARCH_REGISTRY_DSN nicht gesetzt")
 	}
 	addr := os.Getenv("NEXARCH_METRICS_LISTEN_ADDR")
 	if addr == "" {
 		addr = ":8085"
 	}
 	ctx := context.Background()
 	pool, err := db.Connect(ctx, dsn)
 	if err != nil {
 		log.Fatalf("db: %v", err)
 	}
 	defer pool.Close()
 	sourceStore := metrics.NewSourceStore(pool)
 	agg := metrics.NewAggregator(metrics.NewCoreRegistry(), sourceStore.Provide)
 	mux := http.NewServeMux()
 	mux.HandleFunc("/metrics", agg.Handler())
 	mux.HandleFunc("/healthz", func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusOK) })
 	log.Printf("metrics-devserver listening on %s", addr)
 	log.Fatal(http.ListenAndServe(addr, mux))
 }
@@ -0,0 +1,66 @@
 // statuspage-devserver stellt das OPS-02-Backend (internal/statuspage) fuer
 // die Next.js-Statusseite bereit und startet den periodischen Poller.
 // Getrennt von cmd/core aus demselben Grund wie die anderen *-devserver.
 package main
 import (
 	"context"
 	"log"
 	"net/http"
 	"os"
 	"strconv"
 	"time"
 	"gitea.perlbach24.de/scripte/nexarch/internal/db"
 	"gitea.perlbach24.de/scripte/nexarch/internal/statuspage"
 )
 func main() {
 	dsn := os.Getenv("NEXARCH_REGISTRY_DSN")
 	if dsn == "" {
 		log.Fatal("NEXARCH_REGISTRY_DSN nicht gesetzt")
 	}
 	addr := os.Getenv("NEXARCH_STATUSPAGE_LISTEN_ADDR")
 	if addr == "" {
 		addr = ":8084"
 	}
 	intervalSeconds := 10
 	if v := os.Getenv("NEXARCH_STATUSPAGE_POLL_INTERVAL_SECONDS"); v != "" {
 		if parsed, err := strconv.Atoi(v); err == nil {
 			intervalSeconds = parsed
 		}
 	}
 	ctx := context.Background()
 	pool, err := db.Connect(ctx, dsn)
 	if err != nil {
 		log.Fatalf("db: %v", err)
 	}
 	defer pool.Close()
 	store := statuspage.NewStore(pool)
 	checker := statuspage.NewHTTPChecker(2 * time.Second)
 	poller := statuspage.NewPoller(store, checker)
 	go poller.Run(ctx, time.Duration(intervalSeconds)*time.Second)
 	mux := http.NewServeMux()
 	mux.HandleFunc("/status/overview", withCORS(store.OverviewHandler))
 	mux.HandleFunc("/status/history", withCORS(store.HistoryHandler))
 	mux.HandleFunc("/healthz", func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusOK) })
 	log.Printf("statuspage-devserver listening on %s (poll-intervall: %ds)", addr, intervalSeconds)
 	log.Fatal(http.ListenAndServe(addr, mux))
 }
 func withCORS(next http.HandlerFunc) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
 		w.Header().Set("Access-Control-Allow-Origin", "*")
 		w.Header().Set("Access-Control-Allow-Methods", "GET, OPTIONS")
 		w.Header().Set("Access-Control-Allow-Headers", "Content-Type")
 		if r.Method == http.MethodOptions {
 			w.WriteHeader(http.StatusOK)
 			return
 		}
 		next(w, r)
 	}
 }
@@ -1,19 +0,0 @@
 package metrics
 import "github.com/prometheus/client_golang/prometheus"
 // NewCoreRegistry liefert das Prometheus-Registry fuer die EIGENEN
 // Kennzahlen des Core-Dienstes (Akzeptanzkriterium 1) — alle Namen tragen
 // das Praefix "nexarch_core_" gemaess der im Paketkommentar dokumentierten
 // Namenskonvention (Akzeptanzkriterium 3). Ein eigenes Registry statt des
 // globalen DefaultRegisterer, damit Tests unabhaengig voneinander sind.
 func NewCoreRegistry() *prometheus.Registry {
 	reg := prometheus.NewRegistry()
 	reg.MustRegister(
 		prometheus.NewGaugeFunc(prometheus.GaugeOpts{
 			Name: "nexarch_core_up",
 			Help: "1, solange der Core-Dienst laeuft und Metriken liefern kann.",
 		}, func() float64 { return 1 }),
 	)
 	return reg
 }
@@ -1,168 +0,0 @@
 // Package metrics implementiert Core OPS-03: einen zentralen /metrics-
 // Endpunkt im Prometheus-Textformat, der Kennzahlen des Core-Dienstes UND
 // aggregierte Kennzahlen aller registrierten Module bereitstellt — offenes
 // Pull-Modell nach Prometheus-Vorbild, kein proprietaerer Push-Mechanismus.
 //
 // Namenskonvention (Akzeptanzkriterium 3, modulübergreifend konsistent):
 //
 //	nexarch_core_<name>            — Kennzahlen des Core-Dienstes selbst
 //	nexarch_module_<modul>_<name>  — von einem Modul gescrapte Kennzahl
 //	                                  <name>, umbenannt mit dem
 //	                                  Modulnamen als Praefix
 //
 // Ein Modul liefert seine eigenen Kennzahlen unter EIGENEM Namen (z.B.
 // "requests_total") unter seinem eigenen /metrics-Endpunkt — dieses Paket
 // benennt sie beim Einsammeln konsistent um, damit im aggregierten Core-
 // Endpunkt niemals zwei Module denselben Metrik-Namen kollidieren lassen.
 package metrics
 import (
 	"context"
 	"fmt"
 	"net/http"
 	"time"
 	"github.com/prometheus/client_golang/prometheus"
 	dto "github.com/prometheus/client_model/go"
 	"github.com/prometheus/common/expfmt"
 	"github.com/prometheus/common/model"
 )
 // init erzwingt das klassische Prometheus-Namensschema (a-z, A-Z, 0-9, _)
 // fuer die Namensvalidierung von expfmt/model — ohne diese explizite
 // Festlegung liefert die Bibliothek "Invalid name validation scheme
 // requested: unset" beim Parsen/Kodieren, da sie den globalen Default in
 // dieser Version nicht mehr implizit setzt.
 func init() {
 	model.NameValidationScheme = model.LegacyValidation
 }
 // Source ist EIN registriertes Modul mit seinem eigenen /metrics-Endpunkt
 // (siehe internal/health fuer das analoge Muster bei Readiness-Checks).
 type Source struct {
 	ModuleName string
 	MetricsURL string
 }
 // SourceProvider liefert die aktuell registrierten Module — typischerweise
 // rueckgebunden an internal/moduleregistry.Registry.List (API-02) ueber
 // einen kleinen Adapter im aufrufenden Code, damit dieses Paket
 // internal/moduleregistry nicht direkt importieren muss (Kein Umbau
 // angrenzender Bereiche). Ein NEU registriertes Modul erscheint automatisch
 // beim naechsten Aufruf von Aggregator.Handler, OHNE Codeaenderung an diesem
 // Paket (Akzeptanzkriterium 2 / Pruefung 2).
 type SourceProvider func(ctx context.Context) ([]Source, error)
 // FetchTimeout begrenzt, wie lange EIN Modul-Scrape maximal dauern darf —
 // ein haengendes Modul darf den gesamten Aggregations-Request nicht
 // verzoegern (Pruefung 1: Antwort unter Last innerhalb definierter Zeit).
 const FetchTimeout = 2 * time.Second
 // Aggregator sammelt Core-eigene Metriken (coreGatherer) und die Metriken
 // aller ueber sourceProvider gemeldeten Module in EINER Antwort ein.
 type Aggregator struct {
 	coreGatherer   prometheus.Gatherer
 	sourceProvider SourceProvider
 	client         *http.Client
 }
 func NewAggregator(coreGatherer prometheus.Gatherer, sourceProvider SourceProvider) *Aggregator {
 	return &Aggregator{
 		coreGatherer:   coreGatherer,
 		sourceProvider: sourceProvider,
 		client:         &http.Client{Timeout: FetchTimeout},
 	}
 }
 // Gather implementiert prometheus.Gatherer: liefert Core-Metriken PLUS alle
 // erreichbaren Modul-Metriken (umbenannt gemaess Namenskonvention) in einer
 // gemeinsamen Liste von MetricFamilies.
 func (a *Aggregator) Gather(ctx context.Context) ([]*dto.MetricFamily, error) {
 	families, err := a.coreGatherer.Gather()
 	if err != nil {
 		return nil, fmt.Errorf("core-metriken einsammeln: %w", err)
 	}
 	sources, err := a.sourceProvider(ctx)
 	if err != nil {
 		return nil, fmt.Errorf("modul-quellen ermitteln: %w", err)
 	}
 	// Module werden NEBENLAEUFIG gescrapt (dasselbe Muster wie
 	// internal/health.Registry.CheckAll) — ein langsames/nicht erreichbares
 	// Modul haelt weder andere Module noch den Gesamt-Request auf.
 	type fetchResult struct {
 		families []*dto.MetricFamily
 	}
 	resultCh := make(chan fetchResult, len(sources))
 	for _, src := range sources {
 		go func(src Source) {
 			fetchCtx, cancel := context.WithTimeout(ctx, FetchTimeout)
 			defer cancel()
 			mf, err := a.fetchAndRename(fetchCtx, src)
 			if err != nil {
 				resultCh <- fetchResult{} // Fehlerfall: einfach nichts beitragen, Aggregation laeuft weiter
 				return
 			}
 			resultCh <- fetchResult{families: mf}
 		}(src)
 	}
 	for range sources {
 		r := <-resultCh
 		families = append(families, r.families...)
 	}
 	return families, nil
 }
 // fetchAndRename ruft die /metrics-URL eines Moduls ab, parst das
 // Prometheus-Textformat und benennt jede Metrik gemaess der
 // Namenskonvention um (Akzeptanzkriterium 2 + 3).
 func (a *Aggregator) fetchAndRename(ctx context.Context, src Source) ([]*dto.MetricFamily, error) {
 	req, err := http.NewRequestWithContext(ctx, http.MethodGet, src.MetricsURL, nil)
 	if err != nil {
 		return nil, err
 	}
 	resp, err := a.client.Do(req)
 	if err != nil {
 		return nil, err
 	}
 	defer resp.Body.Close()
 	if resp.StatusCode != http.StatusOK {
 		return nil, fmt.Errorf("modul %s: unerwarteter status %d", src.ModuleName, resp.StatusCode)
 	}
 	parser := expfmt.NewTextParser(model.LegacyValidation)
 	parsed, err := parser.TextToMetricFamilies(resp.Body)
 	if err != nil {
 		return nil, fmt.Errorf("modul %s: metrik-text nicht parsebar: %w", src.ModuleName, err)
 	}
 	out := make([]*dto.MetricFamily, 0, len(parsed))
 	for name, mf := range parsed {
 		renamed := fmt.Sprintf("nexarch_module_%s_%s", src.ModuleName, name)
 		mf.Name = &renamed
 		out = append(out, mf)
 	}
 	return out, nil
 }
 // Handler liefert einen HTTP-Handler, der Gather aufruft und das Ergebnis im
 // Prometheus-Textformat ausgibt (Akzeptanzkriterium 1).
 func (a *Aggregator) Handler() http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
 		families, err := a.Gather(r.Context())
 		if err != nil {
 			http.Error(w, "metriken konnten nicht eingesammelt werden", http.StatusInternalServerError)
 			return
 		}
 		w.Header().Set("Content-Type", string(expfmt.NewFormat(expfmt.TypeTextPlain)))
 		enc := expfmt.NewEncoder(w, expfmt.NewFormat(expfmt.TypeTextPlain))
 		for _, mf := range families {
 			if err := enc.Encode(mf); err != nil {
 				return
 			}
 		}
 	}
 }
@@ -1,179 +0,0 @@
 package metrics
 import (
 	"context"
 	"fmt"
 	"net/http"
 	"net/http/httptest"
 	"strings"
 	"sync"
 	"testing"
 	"time"
 	"github.com/prometheus/common/expfmt"
 	"github.com/prometheus/common/model"
 )
 func fakeModuleServer(metricName string) *httptest.Server {
 	return httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		w.Header().Set("Content-Type", "text/plain; version=0.0.4")
 		fmt.Fprintf(w, "# HELP %s ein test-zaehler\n# TYPE %s counter\n%s 42\n", metricName, metricName, metricName)
 	}))
 }
 // Akzeptanzkriterium 1: Core liefert unter dem Handler valides
 // Prometheus-Textformat mit den eigenen Kennzahlen.
 func TestHandler_ServesCoreMetricsInPrometheusFormat(t *testing.T) {
 	agg := NewAggregator(NewCoreRegistry(), func(ctx context.Context) ([]Source, error) { return nil, nil })
 	req := httptest.NewRequest(http.MethodGet, "/metrics", nil)
 	rec := httptest.NewRecorder()
 	agg.Handler()(rec, req)
 	if rec.Code != http.StatusOK {
 		t.Fatalf("status = %d, want 200", rec.Code)
 	}
 	parser := expfmt.NewTextParser(model.LegacyValidation)
 	families, err := parser.TextToMetricFamilies(strings.NewReader(rec.Body.String()))
 	if err != nil {
 		t.Fatalf("antwort ist kein valides prometheus-textformat: %v", err)
 	}
 	if _, ok := families["nexarch_core_up"]; !ok {
 		t.Fatalf("erwartet 'nexarch_core_up' unter den core-metriken, habe: %v", keysOf(families))
 	}
 }
 func keysOf[V any](m map[string]V) []string {
 	out := make([]string, 0, len(m))
 	for k := range m {
 		out = append(out, k)
 	}
 	return out
 }
 // Akzeptanzkriterium 2 + Pruefung 2: ein NEU registriertes Modul erscheint
 // in der Aggregation, OHNE dass dieses Paket oder der Aufrufer Code
 // aendern muss — die Quelle kommt ausschliesslich aus sourceProvider.
 func TestHandler_NewlyRegisteredModuleAppearsWithoutCodeChange(t *testing.T) {
 	moduleServer := fakeModuleServer("requests_total")
 	defer moduleServer.Close()
 	// Simuliert eine sich zur Laufzeit aendernde Modul-Liste (z.B. aus
 	// SourceStore.Provide) — zunaechst LEER, dann mit einem Eintrag.
 	var sources []Source
 	var mu sync.Mutex
 	provider := func(ctx context.Context) ([]Source, error) {
 		mu.Lock()
 		defer mu.Unlock()
 		out := make([]Source, len(sources))
 		copy(out, sources)
 		return out, nil
 	}
 	agg := NewAggregator(NewCoreRegistry(), provider)
 	// Vor der Registrierung: Modul-Metrik nicht vorhanden.
 	rec1 := httptest.NewRecorder()
 	agg.Handler()(rec1, httptest.NewRequest(http.MethodGet, "/metrics", nil))
 	if strings.Contains(rec1.Body.String(), "requests_total") {
 		t.Fatal("modul-metrik haette vor registrierung nicht erscheinen duerfen")
 	}
 	// Modul wird "registriert" (kein Code hier oder in metrics.go aendert sich).
 	mu.Lock()
 	sources = append(sources, Source{ModuleName: "dms", MetricsURL: moduleServer.URL})
 	mu.Unlock()
 	rec2 := httptest.NewRecorder()
 	agg.Handler()(rec2, httptest.NewRequest(http.MethodGet, "/metrics", nil))
 	body := rec2.Body.String()
 	if !strings.Contains(body, "nexarch_module_dms_requests_total") {
 		t.Fatalf("erwartet umbenannte modul-metrik 'nexarch_module_dms_requests_total' nach registrierung, body:\n%s", body)
 	}
 }
 // Akzeptanzkriterium 3: Namenskonvention "nexarch_module_<modul>_<name>"
 // wird tatsaechlich angewendet.
 func TestFetchAndRename_AppliesNamingConvention(t *testing.T) {
 	moduleServer := fakeModuleServer("queue_depth")
 	defer moduleServer.Close()
 	agg := NewAggregator(NewCoreRegistry(), nil)
 	families, err := agg.fetchAndRename(context.Background(), Source{ModuleName: "mail", MetricsURL: moduleServer.URL})
 	if err != nil {
 		t.Fatalf("fetchAndRename: %v", err)
 	}
 	if len(families) != 1 || families[0].GetName() != "nexarch_module_mail_queue_depth" {
 		t.Fatalf("erwartet genau 1 metrik 'nexarch_module_mail_queue_depth', habe: %+v", families)
 	}
 }
 // Ein nicht erreichbares Modul darf die Aggregation der uebrigen und die
 // Gesamtantwort nicht verhindern (dieselbe Resilienz wie OPS-02).
 func TestHandler_UnreachableModuleDoesNotBreakAggregation(t *testing.T) {
 	reachable := fakeModuleServer("healthy_metric")
 	defer reachable.Close()
 	unreachable := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {}))
 	unreachableURL := unreachable.URL
 	unreachable.Close() // sofort schliessen -> Verbindung schlaegt fehl
 	provider := func(ctx context.Context) ([]Source, error) {
 		return []Source{
 			{ModuleName: "ok", MetricsURL: reachable.URL},
 			{ModuleName: "kaputt", MetricsURL: unreachableURL},
 		}, nil
 	}
 	agg := NewAggregator(NewCoreRegistry(), provider)
 	rec := httptest.NewRecorder()
 	agg.Handler()(rec, httptest.NewRequest(http.MethodGet, "/metrics", nil))
 	if rec.Code != http.StatusOK {
 		t.Fatalf("status = %d, want 200 trotz einem nicht erreichbaren modul", rec.Code)
 	}
 	body := rec.Body.String()
 	if !strings.Contains(body, "nexarch_module_ok_healthy_metric") {
 		t.Fatal("erreichbares modul haette trotz ausfall des anderen aggregiert werden sollen")
 	}
 	if strings.Contains(body, "kaputt") {
 		t.Fatal("nicht erreichbares modul haette keine metrik beitragen duerfen")
 	}
 }
 // Pruefung 1: Endpunkt antwortet unter mehreren gleichzeitigen Anfragen
 // innerhalb definierter Zeit — kein unbeschraenktes Blockieren durch
 // langsame Module (FetchTimeout begrenzt jeden Scrape).
 func TestHandler_RespondsWithinBoundedTimeUnderLoad(t *testing.T) {
 	hangingServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		time.Sleep(10 * time.Second) // wuerde ohne timeout jede anfrage blockieren
 	}))
 	defer hangingServer.Close()
 	provider := func(ctx context.Context) ([]Source, error) {
 		return []Source{{ModuleName: "haengend", MetricsURL: hangingServer.URL}}, nil
 	}
 	agg := NewAggregator(NewCoreRegistry(), provider)
 	const concurrentRequests = 10
 	var wg sync.WaitGroup
 	start := time.Now()
 	for i := 0; i < concurrentRequests; i++ {
 		wg.Add(1)
 		go func() {
 			defer wg.Done()
 			rec := httptest.NewRecorder()
 			agg.Handler()(rec, httptest.NewRequest(http.MethodGet, "/metrics", nil))
 			if rec.Code != http.StatusOK {
 				t.Errorf("status = %d, want 200", rec.Code)
 			}
 		}()
 	}
 	wg.Wait()
 	elapsed := time.Since(start)
 	if elapsed > FetchTimeout+3*time.Second {
 		t.Fatalf("%d gleichzeitige anfragen brauchten %s, erwartet deutlich unter %s durch FetchTimeout",
 			concurrentRequests, elapsed, FetchTimeout+3*time.Second)
 	}
 }
@@ -1,52 +0,0 @@
 package metrics
 import (
 	"context"
 	"fmt"
 	"github.com/jackc/pgx/v5/pgxpool"
 )
 // SourceStore persistiert, welche Module ihre Metriken unter welcher URL
 // bereitstellen — dieselbe Postgres-basierte "kein Code-Deploy noetig"-
 // Konvention wie internal/statuspage.Store.RegisterTarget (OPS-02): ein neu
 // registriertes Modul erscheint automatisch in der Aggregation, sobald es
 // hier eingetragen ist (Akzeptanzkriterium 2 / Pruefung 2).
 type SourceStore struct {
 	pool *pgxpool.Pool
 }
 func NewSourceStore(pool *pgxpool.Pool) *SourceStore {
 	return &SourceStore{pool: pool}
 }
 func (s *SourceStore) RegisterSource(ctx context.Context, moduleName, metricsURL string) error {
 	_, err := s.pool.Exec(ctx, `
 		INSERT INTO metrics_sources (module_name, metrics_url)
 		VALUES ($1, $2)
 		ON CONFLICT (module_name) DO UPDATE SET metrics_url = $2
 	`, moduleName, metricsURL)
 	if err != nil {
 		return fmt.Errorf("metrik-quelle speichern: %w", err)
 	}
 	return nil
 }
 // Provide implementiert SourceProvider direkt aus der Datenbank.
 func (s *SourceStore) Provide(ctx context.Context) ([]Source, error) {
 	rows, err := s.pool.Query(ctx, `SELECT module_name, metrics_url FROM metrics_sources ORDER BY module_name`)
 	if err != nil {
 		return nil, fmt.Errorf("metrik-quellen auflisten: %w", err)
 	}
 	defer rows.Close()
 	var out []Source
 	for rows.Next() {
 		var src Source
 		if err := rows.Scan(&src.ModuleName, &src.MetricsURL); err != nil {
 			return nil, fmt.Errorf("metrik-quelle lesen: %w", err)
 		}
 		out = append(out, src)
 	}
 	return out, rows.Err()
 }
@@ -1,60 +0,0 @@
 package metrics
 import (
 	"context"
 	"fmt"
 	"os"
 	"testing"
 	"time"
 	"github.com/jackc/pgx/v5/pgxpool"
 )
 func setupSourceStoreTest(t *testing.T) (*SourceStore, func()) {
 	t.Helper()
 	adminDSN := os.Getenv("TEST_ADMIN_DSN")
 	if adminDSN == "" {
 		t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
 	}
 	ctx := context.Background()
 	pool, err := pgxpool.New(ctx, adminDSN)
 	if err != nil {
 		t.Fatalf("pool: %v", err)
 	}
 	if _, err := pool.Exec(ctx, `
 		CREATE TABLE IF NOT EXISTS metrics_sources (module_name TEXT PRIMARY KEY, metrics_url TEXT NOT NULL)
 	`); err != nil {
 		t.Fatalf("schema: %v", err)
 	}
 	cleanup := func() { pool.Close() }
 	return NewSourceStore(pool), cleanup
 }
 // Akzeptanzkriterium 2 / Pruefung 2 auf Persistenz-Ebene: eine ueber die
 // Datenbank registrierte Quelle ist sofort ueber Provide() sichtbar — genau
 // der Mechanismus, der ein neues Modul ohne Core-Codeaenderung erscheinen
 // laesst.
 func TestSourceStore_RegisterSourceAppearsInProvide(t *testing.T) {
 	store, cleanup := setupSourceStoreTest(t)
 	defer cleanup()
 	ctx := context.Background()
 	name := fmt.Sprintf("modul-%d", time.Now().UnixNano())
 	if err := store.RegisterSource(ctx, name, "http://example.invalid/metrics"); err != nil {
 		t.Fatalf("registersource: %v", err)
 	}
 	sources, err := store.Provide(ctx)
 	if err != nil {
 		t.Fatalf("provide: %v", err)
 	}
 	found := false
 	for _, s := range sources {
 		if s.ModuleName == name {
 			found = true
 		}
 	}
 	if !found {
 		t.Fatalf("erwartet %s in provide()-ergebnis, habe: %+v", name, sources)
 	}
 }
@@ -0,0 +1,273 @@
 // Package statuspage implementiert Core OPS-02: eine zentrale Statusseite,
 // die den Health-Zustand aller registrierten Module aggregiert und den
 // Verlauf vergangener Statusaenderungen speichert. Baut auf OPS-01
 // (internal/health) auf, indem es GENAU die dort etablierten
 // Readiness-Endpunkte je Modul abfragt — dieses Paket dupliziert keine
 // Health-Check-Logik, es aggregiert nur deren Ergebnisse ueber die Zeit.
 package statuspage
 import (
 	"context"
 	"encoding/json"
 	"fmt"
 	"net/http"
 	"time"
 	"github.com/jackc/pgx/v5"
 	"github.com/jackc/pgx/v5/pgxpool"
 )
 // Status ist der aggregierte Zustand EINES Moduls zu einem Zeitpunkt.
 type Status string
 const (
 	StatusUp   Status = "up"
 	StatusDown Status = "down"
 )
 // Target ist ein zu ueberwachendes Modul mit seiner Readiness-URL
 // (OPS-01-Endpunkt, z.B. "http://dms:8080/readyz"). Eigenstaendige
 // Konfiguration statt Erweiterung von internal/moduleregistry.Module, um
 // API-02 nicht anzufassen (Kein Umbau angrenzender Bereiche).
 type Target struct {
 	Name      string
 	HealthURL string
 }
 // Store persistiert Ueberwachungsziele und den Verlauf ihrer
 // Statusaenderungen.
 type Store struct {
 	pool *pgxpool.Pool
 }
 func NewStore(pool *pgxpool.Pool) *Store {
 	return &Store{pool: pool}
 }
 // RegisterTarget traegt ein zu ueberwachendes Modul ein oder aktualisiert
 // dessen URL (Akzeptanzkriterium 1: "aller registrierten Module").
 func (s *Store) RegisterTarget(ctx context.Context, t Target) error {
 	_, err := s.pool.Exec(ctx, `
 		INSERT INTO status_targets (name, health_url)
 		VALUES ($1, $2)
 		ON CONFLICT (name) DO UPDATE SET health_url = $2
 	`, t.Name, t.HealthURL)
 	if err != nil {
 		return fmt.Errorf("ueberwachungsziel speichern: %w", err)
 	}
 	return nil
 }
 func (s *Store) ListTargets(ctx context.Context) ([]Target, error) {
 	rows, err := s.pool.Query(ctx, `SELECT name, health_url FROM status_targets ORDER BY name`)
 	if err != nil {
 		return nil, fmt.Errorf("ueberwachungsziele auflisten: %w", err)
 	}
 	defer rows.Close()
 	var out []Target
 	for rows.Next() {
 		var t Target
 		if err := rows.Scan(&t.Name, &t.HealthURL); err != nil {
 			return nil, fmt.Errorf("ueberwachungsziel lesen: %w", err)
 		}
 		out = append(out, t)
 	}
 	return out, rows.Err()
 }
 // recordIfChanged schreibt NUR dann einen neuen Verlaufseintrag, wenn sich
 // der Status seit dem letzten Eintrag geaendert hat (oder es der erste
 // Eintrag ist) — der Verlauf zeigt Statusaenderungen (Akzeptanzkriterium 3),
 // nicht jede einzelne Abfrage.
 func (s *Store) recordIfChanged(ctx context.Context, name string, status Status) error {
 	var lastStatus string
 	err := s.pool.QueryRow(ctx, `
 		SELECT status FROM status_history WHERE name = $1 ORDER BY changed_at DESC LIMIT 1
 	`, name).Scan(&lastStatus)
 	if err != nil && err != pgx.ErrNoRows {
 		return fmt.Errorf("letzten status lesen: %w", err)
 	}
 	if err == nil && lastStatus == string(status) {
 		return nil // keine Aenderung, kein neuer Eintrag
 	}
 	if _, err := s.pool.Exec(ctx, `
 		INSERT INTO status_history (name, status, changed_at) VALUES ($1, $2, now())
 	`, name, string(status)); err != nil {
 		return fmt.Errorf("statuseintrag schreiben: %w", err)
 	}
 	return nil
 }
 // ModuleStatus ist der aktuelle Zustand EINES Moduls fuer die Uebersicht.
 type ModuleStatus struct {
 	Name        string    `json:"name"`
 	Status      Status    `json:"status"`
 	LastChecked time.Time `json:"last_checked"`
 }
 // Overview liefert den aktuellen (letzten bekannten) Status jedes
 // registrierten Ziels (Akzeptanzkriterium 1). Ziele ohne jemals erfolgte
 // Pruefung erscheinen mit Status "down" — ein Modul, ueber das nichts
 // bekannt ist, gilt als nicht verfuegbar (Fail-Safe-Default), nicht als
 // stillschweigend "ok".
 func (s *Store) Overview(ctx context.Context) ([]ModuleStatus, error) {
 	targets, err := s.ListTargets(ctx)
 	if err != nil {
 		return nil, err
 	}
 	out := make([]ModuleStatus, 0, len(targets))
 	for _, t := range targets {
 		var status string
 		var changedAt time.Time
 		err := s.pool.QueryRow(ctx, `
 			SELECT status, changed_at FROM status_history WHERE name = $1 ORDER BY changed_at DESC LIMIT 1
 		`, t.Name).Scan(&status, &changedAt)
 		if err == pgx.ErrNoRows {
 			out = append(out, ModuleStatus{Name: t.Name, Status: StatusDown})
 			continue
 		}
 		if err != nil {
 			return nil, fmt.Errorf("aktuellen status lesen (%s): %w", t.Name, err)
 		}
 		out = append(out, ModuleStatus{Name: t.Name, Status: Status(status), LastChecked: changedAt})
 	}
 	return out, nil
 }
 // HistoryEntry ist EIN Verlaufseintrag (Akzeptanzkriterium 3).
 type HistoryEntry struct {
 	Status    Status    `json:"status"`
 	ChangedAt time.Time `json:"changed_at"`
 }
 func (s *Store) History(ctx context.Context, name string) ([]HistoryEntry, error) {
 	rows, err := s.pool.Query(ctx, `
 		SELECT status, changed_at FROM status_history WHERE name = $1 ORDER BY changed_at DESC
 	`, name)
 	if err != nil {
 		return nil, fmt.Errorf("verlauf abfragen: %w", err)
 	}
 	defer rows.Close()
 	var out []HistoryEntry
 	for rows.Next() {
 		var e HistoryEntry
 		var status string
 		if err := rows.Scan(&status, &e.ChangedAt); err != nil {
 			return nil, fmt.Errorf("verlaufseintrag lesen: %w", err)
 		}
 		e.Status = Status(status)
 		out = append(out, e)
 	}
 	return out, rows.Err()
 }
 // HTTPChecker fragt die Readiness-URL eines Moduls ab (OPS-01-Endpunkt) und
 // liefert StatusUp NUR bei HTTP 200 — jeder andere Statuscode ODER ein
 // Netzwerkfehler/Timeout gilt als StatusDown. Ein einzelnes nicht
 // erreichbares Modul liefert einen FEHLERFREIEN StatusDown-Wert statt eines
 // Go-Errors, damit Poller.Run ein fehlerhaftes Modul niemals mit einem
 // anderen verwechseln oder den gesamten Zyklus abbrechen kann
 // (Akzeptanzkriterium 2).
 type HTTPChecker struct {
 	Client  *http.Client
 	Timeout time.Duration
 }
 func NewHTTPChecker(timeout time.Duration) *HTTPChecker {
 	return &HTTPChecker{Client: &http.Client{}, Timeout: timeout}
 }
 func (c *HTTPChecker) Check(ctx context.Context, url string) Status {
 	ctx, cancel := context.WithTimeout(ctx, c.Timeout)
 	defer cancel()
 	req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
 	if err != nil {
 		return StatusDown
 	}
 	resp, err := c.Client.Do(req)
 	if err != nil {
 		return StatusDown
 	}
 	defer resp.Body.Close()
 	if resp.StatusCode == http.StatusOK {
 		return StatusUp
 	}
 	return StatusDown
 }
 // Poller fragt periodisch alle Ziele ab und schreibt Statusaenderungen fort.
 type Poller struct {
 	store   *Store
 	checker *HTTPChecker
 }
 func NewPoller(store *Store, checker *HTTPChecker) *Poller {
 	return &Poller{store: store, checker: checker}
 }
 // PollOnce prueft ALLE Ziele in einem Durchlauf. Ein fehlschlagendes Ziel
 // (Netzwerkfehler, Timeout, Nicht-200) wird als StatusDown vermerkt und
 // haelt die Pruefung der UEBRIGEN Ziele nicht auf — die Schleife laeuft
 // sequenziell weiter, kein Ziel kann ein anderes blockieren
 // (Akzeptanzkriterium 2 / Pruefung 2).
 func (p *Poller) PollOnce(ctx context.Context) error {
 	targets, err := p.store.ListTargets(ctx)
 	if err != nil {
 		return err
 	}
 	for _, t := range targets {
 		status := p.checker.Check(ctx, t.HealthURL)
 		if err := p.store.recordIfChanged(ctx, t.Name, status); err != nil {
 			// Ein Schreibfehler fuer EIN Ziel darf die Pruefung der anderen
 			// nicht verhindern — dieselbe Fail-Isolation wie bei einem
 			// unerreichbaren Modul.
 			continue
 		}
 	}
 	return nil
 }
 // Run ruft PollOnce in festen Abstaenden auf, bis ctx beendet wird —
 // dieselbe Konvention wie internal/tenant.Lifecycle.RunSweeper.
 func (p *Poller) Run(ctx context.Context, interval time.Duration) {
 	ticker := time.NewTicker(interval)
 	defer ticker.Stop()
 	for {
 		select {
 		case <-ctx.Done():
 			return
 		case <-ticker.C:
 			_ = p.PollOnce(ctx)
 		}
 	}
 }
 // --- HTTP-Bindung fuer die Oberflaeche ---
 func (s *Store) OverviewHandler(w http.ResponseWriter, r *http.Request) {
 	overview, err := s.Overview(r.Context())
 	writeJSONResult(w, overview, err)
 }
 func (s *Store) HistoryHandler(w http.ResponseWriter, r *http.Request) {
 	name := r.URL.Query().Get("name")
 	history, err := s.History(r.Context(), name)
 	writeJSONResult(w, history, err)
 }
 func writeJSONResult(w http.ResponseWriter, body any, err error) {
 	w.Header().Set("Content-Type", "application/json")
 	if err != nil {
 		w.WriteHeader(http.StatusInternalServerError)
 		_ = json.NewEncoder(w).Encode(map[string]string{"error": err.Error()})
 		return
 	}
 	w.WriteHeader(http.StatusOK)
 	_ = json.NewEncoder(w).Encode(body)
 }
@@ -0,0 +1,198 @@
 package statuspage
 import (
 	"context"
 	"fmt"
 	"net/http"
 	"net/http/httptest"
 	"os"
 	"testing"
 	"time"
 	"github.com/jackc/pgx/v5/pgxpool"
 )
 func setupTest(t *testing.T) (*Store, func()) {
 	t.Helper()
 	adminDSN := os.Getenv("TEST_ADMIN_DSN")
 	if adminDSN == "" {
 		t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
 	}
 	ctx := context.Background()
 	pool, err := pgxpool.New(ctx, adminDSN)
 	if err != nil {
 		t.Fatalf("pool: %v", err)
 	}
 	if _, err := pool.Exec(ctx, `
 		CREATE TABLE IF NOT EXISTS status_targets (name TEXT PRIMARY KEY, health_url TEXT NOT NULL);
 		CREATE TABLE IF NOT EXISTS status_history (
 			id UUID PRIMARY KEY DEFAULT gen_random_uuid(), name TEXT NOT NULL, status TEXT NOT NULL,
 			changed_at TIMESTAMPTZ NOT NULL DEFAULT now()
 		);
 	`); err != nil {
 		t.Fatalf("schema: %v", err)
 	}
 	cleanup := func() { pool.Close() }
 	return NewStore(pool), cleanup
 }
 func uniqueName(prefix string) string {
 	return fmt.Sprintf("%s-%d", prefix, time.Now().UnixNano())
 }
 // Akzeptanzkriterium 1: Uebersicht zeigt den Status ALLER registrierten
 // Module.
 func TestOverview_ShowsAllRegisteredModules(t *testing.T) {
 	store, cleanup := setupTest(t)
 	defer cleanup()
 	ctx := context.Background()
 	up := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusOK) }))
 	defer up.Close()
 	nameA, nameB := uniqueName("mod-a"), uniqueName("mod-b")
 	if err := store.RegisterTarget(ctx, Target{Name: nameA, HealthURL: up.URL}); err != nil {
 		t.Fatalf("target a: %v", err)
 	}
 	if err := store.RegisterTarget(ctx, Target{Name: nameB, HealthURL: up.URL}); err != nil {
 		t.Fatalf("target b: %v", err)
 	}
 	poller := NewPoller(store, NewHTTPChecker(time.Second))
 	if err := poller.PollOnce(ctx); err != nil {
 		t.Fatalf("poll: %v", err)
 	}
 	overview, err := store.Overview(ctx)
 	if err != nil {
 		t.Fatalf("overview: %v", err)
 	}
 	// Overview() listet ALLE jemals registrierten Ziele (auch aus fruehreren
 	// Testlaeufen auf derselben geteilten Test-DB) — hier wird deshalb nur
 	// der Status von nameA/nameB geprueft, nicht jeder Eintrag der Tabelle.
 	statusByName := map[string]Status{}
 	for _, m := range overview {
 		statusByName[m.Name] = m.Status
 	}
 	if statusByName[nameA] != StatusUp {
 		t.Fatalf("modul %s: status = %s, want up", nameA, statusByName[nameA])
 	}
 	if statusByName[nameB] != StatusUp {
 		t.Fatalf("modul %s: status = %s, want up", nameB, statusByName[nameB])
 	}
 }
 // Akzeptanzkriterium 2 + Pruefung 1/2: ein simulierter Ausfall eines Moduls
 // wird sichtbar, das ANDERE Modul bleibt unbeeinflusst und die Pruefung
 // beider laeuft trotzdem in einem Durchlauf durch (kein Totalausfall).
 func TestPollOnce_IsolatesFailingModuleFromOthers(t *testing.T) {
 	store, cleanup := setupTest(t)
 	defer cleanup()
 	ctx := context.Background()
 	up := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusOK) }))
 	defer up.Close()
 	down := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusInternalServerError) }))
 	down.Close() // Server sofort schliessen -> Verbindung tatsaechlich unerreichbar (simulierter Ausfall)
 	healthyName, downName := uniqueName("healthy"), uniqueName("down")
 	if err := store.RegisterTarget(ctx, Target{Name: healthyName, HealthURL: up.URL}); err != nil {
 		t.Fatalf("target healthy: %v", err)
 	}
 	if err := store.RegisterTarget(ctx, Target{Name: downName, HealthURL: down.URL}); err != nil {
 		t.Fatalf("target down: %v", err)
 	}
 	poller := NewPoller(store, NewHTTPChecker(500*time.Millisecond))
 	if err := poller.PollOnce(ctx); err != nil {
 		t.Fatalf("poll haette trotz einem ausgefallenen modul erfolgreich durchlaufen sollen: %v", err)
 	}
 	overview, err := store.Overview(ctx)
 	if err != nil {
 		t.Fatalf("overview: %v", err)
 	}
 	statusByName := map[string]Status{}
 	for _, m := range overview {
 		statusByName[m.Name] = m.Status
 	}
 	if statusByName[healthyName] != StatusUp {
 		t.Fatalf("healthy modul: status = %s, want up", statusByName[healthyName])
 	}
 	if statusByName[downName] != StatusDown {
 		t.Fatalf("ausgefallenes modul: status = %s, want down", statusByName[downName])
 	}
 }
 // Akzeptanzkriterium 3: Verlauf vergangener Statusaenderungen ist einsehbar.
 func TestHistory_RecordsStatusTransitions(t *testing.T) {
 	store, cleanup := setupTest(t)
 	defer cleanup()
 	ctx := context.Background()
 	name := uniqueName("flaky")
 	up := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusOK) }))
 	defer up.Close()
 	if err := store.RegisterTarget(ctx, Target{Name: name, HealthURL: up.URL}); err != nil {
 		t.Fatalf("target: %v", err)
 	}
 	poller := NewPoller(store, NewHTTPChecker(time.Second))
 	if err := poller.PollOnce(ctx); err != nil {
 		t.Fatalf("poll 1: %v", err)
 	}
 	// Ziel wird "abgeschaltet" (URL zeigt jetzt auf einen bereits
 	// geschlossenen Server) -> naechster Poll erkennt den Statuswechsel.
 	closedURL := up.URL
 	up.Close()
 	if err := store.RegisterTarget(ctx, Target{Name: name, HealthURL: closedURL}); err != nil {
 		t.Fatalf("target aktualisieren: %v", err)
 	}
 	if err := poller.PollOnce(ctx); err != nil {
 		t.Fatalf("poll 2: %v", err)
 	}
 	history, err := store.History(ctx, name)
 	if err != nil {
 		t.Fatalf("history: %v", err)
 	}
 	if len(history) != 2 {
 		t.Fatalf("erwartet genau 2 statuswechsel (up -> down), habe %d: %+v", len(history), history)
 	}
 	if history[0].Status != StatusDown || history[1].Status != StatusUp {
 		t.Fatalf("erwartet verlauf [down, up] (neueste zuerst), habe: %+v", history)
 	}
 }
 // Wiederholte Polls OHNE Statuswechsel duerfen den Verlauf nicht mit
 // identischen Eintraegen fluten (siehe recordIfChanged).
 func TestHistory_DoesNotDuplicateUnchangedStatus(t *testing.T) {
 	store, cleanup := setupTest(t)
 	defer cleanup()
 	ctx := context.Background()
 	name := uniqueName("stable")
 	up := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusOK) }))
 	defer up.Close()
 	if err := store.RegisterTarget(ctx, Target{Name: name, HealthURL: up.URL}); err != nil {
 		t.Fatalf("target: %v", err)
 	}
 	poller := NewPoller(store, NewHTTPChecker(time.Second))
 	for i := 0; i < 3; i++ {
 		if err := poller.PollOnce(ctx); err != nil {
 			t.Fatalf("poll %d: %v", i, err)
 		}
 	}
 	history, err := store.History(ctx, name)
 	if err != nil {
 		t.Fatalf("history: %v", err)
 	}
 	if len(history) != 1 {
 		t.Fatalf("erwartet genau 1 eintrag trotz 3 unveraenderter polls, habe %d", len(history))
 	}
 }
@@ -1 +0,0 @@
 DROP TABLE metrics_sources;
@@ -1,7 +0,0 @@
 -- Metrics-Aggregation ueber Module hinweg (OPS-03, siehe
 -- core-kanban/tickets/OPS-03.md) — welches Modul liefert seine Kennzahlen
 -- unter welcher /metrics-URL.
 CREATE TABLE metrics_sources (
    module_name TEXT PRIMARY KEY,
    metrics_url TEXT NOT NULL
 );
@@ -0,0 +1,2 @@
 DROP TABLE status_history;
 DROP TABLE status_targets;
@@ -0,0 +1,15 @@
 -- Zentrale Statusseite (OPS-02, siehe core-kanban/tickets/OPS-02.md) —
 -- ueberwachte Module und der Verlauf ihrer Statusaenderungen.
 CREATE TABLE status_targets (
    name       TEXT PRIMARY KEY,
    health_url TEXT NOT NULL
 );
 CREATE TABLE status_history (
    id         UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    name       TEXT NOT NULL,
    status     TEXT NOT NULL,
    changed_at TIMESTAMPTZ NOT NULL DEFAULT now()
 );
 CREATE INDEX status_history_name_idx ON status_history (name, changed_at DESC);
@@ -0,0 +1,45 @@
 # @nexarch/shl — UI-Shell & Design-System (Core SHL-01)
 Gemeinsames Paket für alle NEXARCH-Modul-Frontends (Core, DMS, Mail, Archive, Workflow, AI, Connect).
 Ein Modul-Frontend importiert ausschließlich über `index.ts`, kopiert keine Komponenten oder Tokens lokal.
 ## Enthält
 - **Design-Tokens** (`tokens/tokens.ts`) — Farbe (Hell/Dunkel), Abstand, Typografie. Kontrastwerte gegen WCAG 2.1 AA geprüft (siehe `__tests__/tokens.test.ts`).
 - **Theming** (`theme/ThemeProvider.tsx`) — zentrale Hell/Dunkel-Umschaltung, respektiert `prefers-color-scheme`, persistiert in `localStorage`.
 - **i18n-Rahmen** (`i18n/i18n.tsx`) — Umschaltmechanismus Deutsch/Englisch. Modul-Frontends registrieren ihre fachlichen Textbausteine über `registerMessages()`, statt einen eigenen Mechanismus zu bauen.
 - **Basis-Komponenten** (`components/`) — `Shell` (Layout + Navigation), `Table`, `Dialog`, `TextField`/`SelectField`/`CheckboxField`, `Toast`. Alle mit WCAG-2.1-AA-Grundlage (Tastaturbedienung, ARIA-Attribute, Fokus-Management).
 ## Verwendung in einem Modul-Frontend
 ```tsx
 import { ThemeProvider, I18nProvider, ToastProvider, Shell } from "@nexarch/shl";
 export default function RootLayout({ children }: { children: React.ReactNode }) {
  return (
    <ThemeProvider>
      <I18nProvider initialLocale="de">
        <ToastProvider>
          <Shell modules={[]} tenantLabel="Mandant XY">
            {children}
          </Shell>
        </ToastProvider>
      </I18nProvider>
    </ThemeProvider>
  );
 }
 ```
 ## Bekannter offener Punkt
 Die vier bereits gebauten Core-Frontends (`TEN-05`, `LIC-04`, `AUD-04`, `OPS-02`) sind vor diesem Paket entstanden und binden es noch nicht ein — Retrofit ist der nächste Schritt, siehe `nexarch-state.json`.
 ## Tests
 Ausführung auf dem Test-Host (nicht lokal, siehe Projekt-Testinfrastruktur):
 ```bash
 npm install
 npm test
 npm run typecheck
 ```
@@ -0,0 +1,38 @@
 // Prüfung: Tastaturbedienung der Basis-Komponenten funktioniert (SHL-01 Prüfung 2).
 import { describe, expect, it, vi } from "vitest";
 import { fireEvent, render, screen } from "@testing-library/react";
 import { Dialog } from "../components/Dialog";
 import { I18nProvider } from "../i18n/i18n";
 function renderDialog(onClose: () => void) {
  return render(
    <I18nProvider>
      <Dialog open titleId="test-title" title="Test-Dialog" onClose={onClose}>
        <button type="button">Erste Aktion</button>
        <button type="button">Zweite Aktion</button>
      </Dialog>
    </I18nProvider>,
  );
 }
 describe("Dialog: Tastaturbedienung", () => {
  it("schließt sich bei ESC", () => {
    const onClose = vi.fn();
    renderDialog(onClose);
    fireEvent.keyDown(document, { key: "Escape" });
    expect(onClose).toHaveBeenCalledOnce();
  });
  it("setzt den Fokus beim Öffnen auf das erste fokussierbare Element", () => {
    renderDialog(vi.fn());
    const closeButton = screen.getByRole("button", { name: /schließen/i });
    expect(document.activeElement).toBe(closeButton);
  });
  it("ist als modaler Dialog mit Titel-Referenz ausgezeichnet", () => {
    renderDialog(vi.fn());
    const dialog = screen.getByRole("dialog");
    expect(dialog).toHaveAttribute("aria-modal", "true");
    expect(dialog).toHaveAttribute("aria-labelledby", "test-title");
  });
 });
@@ -0,0 +1,39 @@
 // Prüfung: Kontrastwerte erfüllen mindestens AA (SHL-01 Prüfung 3 / Akzeptanzkriterium 4).
 import { describe, expect, it } from "vitest";
 import { colorTokens } from "../tokens/tokens";
 // WCAG-2.1-AA-Kontrastberechnung (relative Luminanz, sRGB) — keine externe Abhängigkeit nötig.
 function relLuminance(hex: string): number {
  const rgb = [1, 3, 5].map((i) => parseInt(hex.slice(i, i + 2), 16) / 255);
  const [r, g, b] = rgb.map((c) => (c <= 0.03928 ? c / 12.92 : ((c + 0.055) / 1.055) ** 2.4));
  return 0.2126 * r + 0.7152 * g + 0.0722 * b;
 }
 function contrastRatio(a: string, b: string): number {
  const l1 = relLuminance(a);
  const l2 = relLuminance(b);
  const [lighter, darker] = l1 > l2 ? [l1, l2] : [l2, l1];
  return (lighter + 0.05) / (darker + 0.05);
 }
 describe("Design-Tokens: WCAG 2.1 AA Kontrast", () => {
  for (const scheme of ["light", "dark"] as const) {
    const c = colorTokens[scheme];
    it(`${scheme}: textPrimary auf background erfüllt AA (>= 4.5:1)`, () => {
      expect(contrastRatio(c.textPrimary, c.background)).toBeGreaterThanOrEqual(4.5);
    });
    it(`${scheme}: textSecondary auf surface erfüllt AA (>= 4.5:1)`, () => {
      expect(contrastRatio(c.textSecondary, c.surface)).toBeGreaterThanOrEqual(4.5);
    });
    it(`${scheme}: accentContrast auf accent erfüllt AA (>= 4.5:1)`, () => {
      expect(contrastRatio(c.accentContrast, c.accent)).toBeGreaterThanOrEqual(4.5);
    });
    it(`${scheme}: dangerContrast auf danger erfüllt AA (>= 4.5:1)`, () => {
      expect(contrastRatio(c.dangerContrast, c.danger)).toBeGreaterThanOrEqual(4.5);
    });
  }
 });
@@ -0,0 +1,88 @@
 "use client";
 // Dialog-Basis-Komponente — SHL-01. WCAG 2.1 AA: Fokus-Falle, ESC schließt, Tastaturbedienung vollständig.
 import { useEffect, useRef } from "react";
 import type { ReactNode } from "react";
 import { useI18n } from "../i18n/i18n";
 const FOCUSABLE_SELECTOR =
  'a[href], button:not([disabled]), textarea:not([disabled]), input:not([disabled]), select:not([disabled]), [tabindex]:not([tabindex="-1"])';
 export interface DialogProps {
  open: boolean;
  onClose: () => void;
  titleId: string;
  title: string;
  children: ReactNode;
 }
 export function Dialog({ open, onClose, titleId, title, children }: DialogProps) {
  const { t } = useI18n();
  const dialogRef = useRef<HTMLDivElement>(null);
  const previouslyFocused = useRef<HTMLElement | null>(null);
  useEffect(() => {
    if (!open) return;
    previouslyFocused.current = document.activeElement as HTMLElement | null;
    const node = dialogRef.current;
    const focusables = node?.querySelectorAll<HTMLElement>(FOCUSABLE_SELECTOR);
    focusables?.[0]?.focus();
    function handleKeyDown(event: KeyboardEvent) {
      if (event.key === "Escape") {
        onClose();
        return;
      }
      if (event.key !== "Tab" || !node) return;
      const items = Array.from(node.querySelectorAll<HTMLElement>(FOCUSABLE_SELECTOR));
      if (items.length === 0) return;
      const first = items[0];
      const last = items[items.length - 1];
      if (event.shiftKey && document.activeElement === first) {
        event.preventDefault();
        last.focus();
      } else if (!event.shiftKey && document.activeElement === last) {
        event.preventDefault();
        first.focus();
      }
    }
    document.addEventListener("keydown", handleKeyDown);
    return () => {
      document.removeEventListener("keydown", handleKeyDown);
      previouslyFocused.current?.focus();
    };
  }, [open, onClose]);
  if (!open) return null;
  return (
    <div
      className="shl-dialog-backdrop"
      role="presentation"
      onMouseDown={(event) => {
        if (event.target === event.currentTarget) onClose();
      }}
    >
      <div
        ref={dialogRef}
        className="shl-dialog"
        role="dialog"
        aria-modal="true"
        aria-labelledby={titleId}
      >
        <div className="shl-dialog-header">
          <h2 id={titleId}>{title}</h2>
          <button type="button" onClick={onClose} aria-label={t("shl.dialog.close")}>
            ×
          </button>
        </div>
        <div className="shl-dialog-body">{children}</div>
      </div>
    </div>
  );
 }
@@ -0,0 +1,98 @@
 // Formularelemente-Basis-Komponenten — SHL-01. WCAG: jedes Feld hat verknüpftes <label>,
 // Fehler werden per aria-describedby + aria-invalid angebunden, nicht nur farblich markiert.
 import { useId } from "react";
 import type { InputHTMLAttributes, ReactNode, SelectHTMLAttributes } from "react";
 interface FieldWrapperProps {
  label: string;
  error?: string;
  hint?: string;
  children: (ids: { inputId: string; describedBy: string | undefined }) => ReactNode;
 }
 function FieldWrapper({ label, error, hint, children }: FieldWrapperProps) {
  const inputId = useId();
  const hintId = hint ? `${inputId}-hint` : undefined;
  const errorId = error ? `${inputId}-error` : undefined;
  const describedBy = [hintId, errorId].filter(Boolean).join(" ") || undefined;
  return (
    <div className="shl-field">
      <label htmlFor={inputId}>{label}</label>
      {children({ inputId, describedBy })}
      {hint && (
        <p id={hintId} className="shl-field-hint">
          {hint}
        </p>
      )}
      {error && (
        <p id={errorId} className="shl-field-error" role="alert">
          {error}
        </p>
      )}
    </div>
  );
 }
 export interface TextFieldProps
  extends Omit<InputHTMLAttributes<HTMLInputElement>, "id" | "aria-describedby"> {
  label: string;
  error?: string;
  hint?: string;
 }
 export function TextField({ label, error, hint, ...inputProps }: TextFieldProps) {
  return (
    <FieldWrapper label={label} error={error} hint={hint}>
      {({ inputId, describedBy }) => (
        <input
          id={inputId}
          aria-describedby={describedBy}
          aria-invalid={error ? true : undefined}
          {...inputProps}
        />
      )}
    </FieldWrapper>
  );
 }
 export interface SelectFieldProps
  extends Omit<SelectHTMLAttributes<HTMLSelectElement>, "id" | "aria-describedby"> {
  label: string;
  error?: string;
  hint?: string;
  children: ReactNode;
 }
 export function SelectField({ label, error, hint, children, ...selectProps }: SelectFieldProps) {
  return (
    <FieldWrapper label={label} error={error} hint={hint}>
      {({ inputId, describedBy }) => (
        <select
          id={inputId}
          aria-describedby={describedBy}
          aria-invalid={error ? true : undefined}
          {...selectProps}
        >
          {children}
        </select>
      )}
    </FieldWrapper>
  );
 }
 export interface CheckboxFieldProps
  extends Omit<InputHTMLAttributes<HTMLInputElement>, "id" | "type"> {
  label: string;
 }
 export function CheckboxField({ label, ...inputProps }: CheckboxFieldProps) {
  const inputId = useId();
  return (
    <div className="shl-field shl-field-checkbox">
      <input id={inputId} type="checkbox" {...inputProps} />
      <label htmlFor={inputId}>{label}</label>
    </div>
  );
 }
@@ -0,0 +1,62 @@
 "use client";
 // Layout-Shell mit Navigation — SHL-01 Akzeptanzkriterium 1.
 // Globale Navigation zeigt nur Module, die Core für Tenant/Benutzer freigibt (Backend entscheidet, UI blendet nur aus).
 import type { ReactNode } from "react";
 import { useI18n } from "../i18n/i18n";
 import { useTheme } from "../theme/ThemeProvider";
 export interface ModuleLink {
  key: string;
  label: string;
  href: string;
  active?: boolean;
 }
 export interface ShellProps {
  modules: ModuleLink[];
  tenantLabel: string;
  children: ReactNode;
 }
 export function Shell({ modules, tenantLabel, children }: ShellProps) {
  const { scheme, toggle } = useTheme();
  const { t } = useI18n();
  return (
    <div className="shl-shell">
      <a className="shl-skip-link" href="#shl-main-content">
        {t("shl.shell.skipToContent", "Zum Inhalt springen")}
      </a>
      <header className="shl-shell-header">
        <nav aria-label={t("shl.shell.moduleNav", "Modul-Navigation")}>
          <ul>
            {modules.map((mod) => (
              <li key={mod.key}>
                <a href={mod.href} aria-current={mod.active ? "page" : undefined}>
                  {mod.label}
                </a>
              </li>
            ))}
          </ul>
        </nav>
        <div className="shl-shell-context">
          <span className="shl-tenant-context">{tenantLabel}</span>
          <button
            type="button"
            onClick={toggle}
            aria-label={
              scheme === "light" ? t("shl.theme.toggleToDark") : t("shl.theme.toggleToLight")
            }
          >
            {scheme === "light" ? "🌙" : "☀️"}
          </button>
        </div>
      </header>
      <main id="shl-main-content" className="shl-shell-content" tabIndex={-1}>
        {children}
      </main>
    </div>
  );
 }
@@ -0,0 +1,83 @@
 // Table-Basis-Komponente — SHL-01. WCAG: semantische <table>, scope auf Kopfzellen, sortierbare Spalten per Tastatur.
 import type { ReactNode } from "react";
 import { useI18n } from "../i18n/i18n";
 export interface TableColumn<Row> {
  key: string;
  header: string;
  render: (row: Row) => ReactNode;
  sortable?: boolean;
 }
 export interface TableProps<Row> {
  columns: TableColumn<Row>[];
  rows: Row[];
  rowKey: (row: Row) => string;
  sortKey?: string;
  sortDirection?: "asc" | "desc";
  onSort?: (key: string) => void;
  caption?: string;
 }
 export function Table<Row>({
  columns,
  rows,
  rowKey,
  sortKey,
  sortDirection,
  onSort,
  caption,
 }: TableProps<Row>) {
  const { t } = useI18n();
  return (
    <table className="shl-table">
      {caption && <caption>{caption}</caption>}
      <thead>
        <tr>
          {columns.map((column) => {
            const isSorted = column.key === sortKey;
            const ariaSort = column.sortable
              ? isSorted
                ? sortDirection === "asc"
                  ? "ascending"
                  : "descending"
                : "none"
              : undefined;
            return (
              <th key={column.key} scope="col" aria-sort={ariaSort}>
                {column.sortable ? (
                  <button
                    type="button"
                    onClick={() => onSort?.(column.key)}
                    className="shl-table-sort-button"
                  >
                    {column.header}
                  </button>
                ) : (
                  column.header
                )}
              </th>
            );
          })}
        </tr>
      </thead>
      <tbody>
        {rows.length === 0 ? (
          <tr>
            <td colSpan={columns.length}>{t("shl.table.noRows")}</td>
          </tr>
        ) : (
          rows.map((row) => (
            <tr key={rowKey(row)}>
              {columns.map((column) => (
                <td key={column.key}>{column.render(row)}</td>
              ))}
            </tr>
          ))
        )}
      </tbody>
    </table>
  );
 }
@@ -0,0 +1,67 @@
 "use client";
 // Toast-Basis-Komponente — SHL-01. WCAG: aria-live sorgt dafür, dass Screenreader Meldungen ansagen.
 import { createContext, useCallback, useContext, useMemo, useState } from "react";
 import type { ReactNode } from "react";
 import { useI18n } from "../i18n/i18n";
 export type ToastVariant = "info" | "success" | "danger" | "warning";
 export interface ToastMessage {
  id: string;
  text: string;
  variant: ToastVariant;
 }
 interface ToastContextValue {
  toasts: ToastMessage[];
  push: (text: string, variant?: ToastVariant) => void;
  dismiss: (id: string) => void;
 }
 const ToastContext = createContext<ToastContextValue | null>(null);
 export function ToastProvider({ children }: { children: ReactNode }) {
  const [toasts, setToasts] = useState<ToastMessage[]>([]);
  const { t } = useI18n();
  const dismiss = useCallback((id: string) => {
    setToasts((current) => current.filter((toast) => toast.id !== id));
  }, []);
  const push = useCallback((text: string, variant: ToastVariant = "info") => {
    const id = `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
    setToasts((current) => [...current, { id, text, variant }]);
  }, []);
  const value = useMemo(() => ({ toasts, push, dismiss }), [toasts, push, dismiss]);
  return (
    <ToastContext.Provider value={value}>
      {children}
      <div className="shl-toast-region" role="status" aria-live="polite" aria-atomic="false">
        {toasts.map((toast) => (
          <div key={toast.id} className={`shl-toast shl-toast-${toast.variant}`}>
            <span>{toast.text}</span>
            <button
              type="button"
              onClick={() => dismiss(toast.id)}
              aria-label={t("shl.toast.dismiss")}
            >
              ×
            </button>
          </div>
        ))}
      </div>
    </ToastContext.Provider>
  );
 }
 export function useToast(): ToastContextValue {
  const ctx = useContext(ToastContext);
  if (!ctx) {
    throw new Error("useToast muss innerhalb von <ToastProvider> aufgerufen werden");
  }
  return ctx;
 }
@@ -0,0 +1,75 @@
 "use client";
 // i18n-Rahmen (mind. Deutsch/Englisch) — SHL-01 Akzeptanzkriterium 5.
 // Liefert nur den Umschaltmechanismus + Basis-Komponenten-Texte.
 // Modul-Frontends liefern ihre eigenen fachlichen Textbausteine über registerMessages(),
 // statt einen eigenen i18n-Mechanismus zu bauen (siehe UI-UX-KONZEPT.md Abschnitt 4).
 import { createContext, useContext, useMemo, useState } from "react";
 import type { ReactNode } from "react";
 export type Locale = "de" | "en";
 type MessageDict = Record<string, string>;
 type MessageBundle = Record<Locale, MessageDict>;
 const baseMessages: MessageBundle = {
  de: {
    "shl.dialog.close": "Schließen",
    "shl.toast.dismiss": "Meldung schließen",
    "shl.table.noRows": "Keine Einträge vorhanden",
    "shl.theme.toggleToLight": "Helles Erscheinungsbild",
    "shl.theme.toggleToDark": "Dunkles Erscheinungsbild",
  },
  en: {
    "shl.dialog.close": "Close",
    "shl.toast.dismiss": "Dismiss message",
    "shl.table.noRows": "No entries",
    "shl.theme.toggleToLight": "Switch to light theme",
    "shl.theme.toggleToDark": "Switch to dark theme",
  },
 };
 // Registry, in die Modul-Frontends ihre eigenen Textbausteine einhängen.
 const registry: MessageBundle = { de: { ...baseMessages.de }, en: { ...baseMessages.en } };
 export function registerMessages(locale: Locale, messages: MessageDict): void {
  registry[locale] = { ...registry[locale], ...messages };
 }
 interface I18nContextValue {
  locale: Locale;
  setLocale: (locale: Locale) => void;
  t: (key: string, fallback?: string) => string;
 }
 const I18nContext = createContext<I18nContextValue | null>(null);
 export function I18nProvider({
  initialLocale = "de",
  children,
 }: {
  initialLocale?: Locale;
  children: ReactNode;
 }) {
  const [locale, setLocale] = useState<Locale>(initialLocale);
  const value = useMemo<I18nContextValue>(
    () => ({
      locale,
      setLocale,
      t: (key: string, fallback?: string) => registry[locale][key] ?? fallback ?? key,
    }),
    [locale],
  );
  return <I18nContext.Provider value={value}>{children}</I18nContext.Provider>;
 }
 export function useI18n(): I18nContextValue {
  const ctx = useContext(I18nContext);
  if (!ctx) {
    throw new Error("useI18n muss innerhalb von <I18nProvider> aufgerufen werden");
  }
  return ctx;
 }
@@ -0,0 +1,25 @@
 // Öffentliche Schnittstelle des Pakets @nexarch/shl — Modul-Frontends importieren ausschließlich hierüber,
 // nicht aus internen Unterpfaden (SHL-01 Akzeptanzkriterium 2: dokumentiert, versioniert, importierbar statt kopiert).
 export { colorTokens, spacing, breakpoints, typography, cssVariables } from "./tokens/tokens";
 export type { ColorScheme, ColorTokens } from "./tokens/tokens";
 export { ThemeProvider, useTheme, currentColors } from "./theme/ThemeProvider";
 export { I18nProvider, useI18n, registerMessages } from "./i18n/i18n";
 export type { Locale } from "./i18n/i18n";
 export { Shell } from "./components/Shell";
 export type { ShellProps, ModuleLink } from "./components/Shell";
 export { Dialog } from "./components/Dialog";
 export type { DialogProps } from "./components/Dialog";
 export { Table } from "./components/Table";
 export type { TableProps, TableColumn } from "./components/Table";
 export { TextField, SelectField, CheckboxField } from "./components/FormElements";
 export type { TextFieldProps, SelectFieldProps, CheckboxFieldProps } from "./components/FormElements";
 export { ToastProvider, useToast } from "./components/Toast";
 export type { ToastMessage, ToastVariant } from "./components/Toast";
@@ -0,0 +1,25 @@
 {
  "name": "@nexarch/shl",
  "version": "0.1.0",
  "private": true,
  "description": "NEXARCH UI-Shell & Design-System (Core SHL-01) — gemeinsames Paket für alle Modul-Frontends.",
  "main": "index.ts",
  "types": "index.ts",
  "scripts": {
    "test": "vitest run",
    "typecheck": "tsc --noEmit"
  },
  "peerDependencies": {
    "react": "^18.3.1",
    "react-dom": "^18.3.1"
  },
  "devDependencies": {
    "@testing-library/jest-dom": "^6.4.8",
    "@testing-library/react": "^16.0.0",
    "@types/react": "18.3.3",
    "@types/react-dom": "18.3.0",
    "jsdom": "^24.1.1",
    "typescript": "5.5.3",
    "vitest": "^2.0.0"
  }
 }
@@ -0,0 +1,81 @@
 "use client";
 // Zentrales Theming (Hell/Dunkel) — SHL-01 Akzeptanzkriterium 6.
 // Einzige Quelle für Hell/Dunkel-Werte; Modul-Frontends schalten nur um, bauen kein eigenes Theming.
 import { createContext, useCallback, useContext, useEffect, useMemo, useState } from "react";
 import type { ReactNode } from "react";
 import { colorTokens, cssVariables, type ColorScheme } from "../tokens/tokens";
 const STORAGE_KEY = "nexarch-shl-theme";
 interface ThemeContextValue {
  scheme: ColorScheme;
  setScheme: (scheme: ColorScheme) => void;
  toggle: () => void;
 }
 const ThemeContext = createContext<ThemeContextValue | null>(null);
 function readStoredScheme(): ColorScheme | null {
  if (typeof window === "undefined") return null;
  try {
    const stored = window.localStorage.getItem(STORAGE_KEY);
    return stored === "light" || stored === "dark" ? stored : null;
  } catch {
    // localStorage kann in privaten Fenstern/eingeschränkten Kontexten fehlschlagen — kein Absturz, nur kein persistierter Zustand.
    return null;
  }
 }
 function systemPrefersDark(): boolean {
  if (typeof window === "undefined" || !window.matchMedia) return false;
  return window.matchMedia("(prefers-color-scheme: dark)").matches;
 }
 export function ThemeProvider({ children }: { children: ReactNode }) {
  const [scheme, setSchemeState] = useState<ColorScheme>("light");
  useEffect(() => {
    const stored = readStoredScheme();
    setSchemeState(stored ?? (systemPrefersDark() ? "dark" : "light"));
  }, []);
  const setScheme = useCallback((next: ColorScheme) => {
    setSchemeState(next);
    try {
      window.localStorage.setItem(STORAGE_KEY, next);
    } catch {
      // Speichern optional — Umschaltung funktioniert auch ohne Persistenz.
    }
  }, []);
  const toggle = useCallback(() => {
    setScheme(scheme === "light" ? "dark" : "light");
  }, [scheme, setScheme]);
  useEffect(() => {
    const vars = cssVariables(scheme);
    const root = document.documentElement;
    for (const [key, value] of Object.entries(vars)) {
      root.style.setProperty(key, value);
    }
    root.dataset.shlTheme = scheme;
  }, [scheme]);
  const value = useMemo(() => ({ scheme, setScheme, toggle }), [scheme, setScheme, toggle]);
  return <ThemeContext.Provider value={value}>{children}</ThemeContext.Provider>;
 }
 export function useTheme(): ThemeContextValue {
  const ctx = useContext(ThemeContext);
  if (!ctx) {
    throw new Error("useTheme muss innerhalb von <ThemeProvider> aufgerufen werden");
  }
  return ctx;
 }
 export function currentColors(scheme: ColorScheme) {
  return colorTokens[scheme];
 }
@@ -0,0 +1,96 @@
 // Design-Tokens: einzige Quelle für Farbe, Abstand, Typografie im gesamten Frontend-Verbund.
 // Modul-Frontends importieren diese Tokens, überschreiben sie nicht lokal (SHL-01 Akzeptanzkriterium 3).
 // Kontrastwerte sind gegen WCAG 2.1 AA geprüft (Akzeptanzkriterium 1/4): mindestens 4.5:1 für Fließtext.
 export type ColorScheme = "light" | "dark";
 export interface ColorTokens {
  background: string;
  surface: string;
  surfaceRaised: string;
  border: string;
  textPrimary: string;
  textSecondary: string;
  accent: string;
  accentContrast: string;
  danger: string;
  dangerContrast: string;
  success: string;
  warning: string;
  focusRing: string;
 }
 // Kontrastwerte geprüft: textPrimary auf background/surface >= 7:1, textSecondary >= 4.5:1,
 // accentContrast auf accent >= 4.5:1 (WCAG AA, siehe SHL-01 Prüfung 3).
 export const colorTokens: Record<ColorScheme, ColorTokens> = {
  light: {
    background: "#FFFFFF",
    surface: "#F5F6F8",
    surfaceRaised: "#FFFFFF",
    border: "#D7DBE0",
    textPrimary: "#14181F",
    textSecondary: "#4B5563",
    accent: "#1D4ED8",
    accentContrast: "#FFFFFF",
    danger: "#B91C1C",
    dangerContrast: "#FFFFFF",
    success: "#15803D",
    warning: "#B45309",
    focusRing: "#1D4ED8",
  },
  dark: {
    background: "#0F1115",
    surface: "#181B21",
    surfaceRaised: "#20242C",
    border: "#333944",
    textPrimary: "#F2F4F7",
    textSecondary: "#B4BAC4",
    accent: "#5B8DEF",
    accentContrast: "#0F1115",
    danger: "#F87171",
    dangerContrast: "#0F1115",
    success: "#4ADE80",
    warning: "#FBBF24",
    focusRing: "#5B8DEF",
  },
 };
 export const spacing = {
  xs: "4px",
  sm: "8px",
  md: "16px",
  lg: "24px",
  xl: "32px",
  xxl: "48px",
 } as const;
 export const breakpoints = {
  mobile: "0px",
  tablet: "768px",
  desktop: "1200px",
 } as const;
 export const typography = {
  fontFamily: "'Inter', 'Segoe UI', system-ui, sans-serif",
  fontFamilyMono: "'JetBrains Mono', ui-monospace, monospace",
  sizeSm: "13px",
  sizeMd: "15px",
  sizeLg: "18px",
  sizeXl: "24px",
  lineHeight: 1.5,
  weightRegular: 400,
  weightMedium: 500,
  weightBold: 600,
 } as const;
 export function cssVariables(scheme: ColorScheme): Record<string, string> {
  const c = colorTokens[scheme];
  const vars: Record<string, string> = {};
  for (const [key, value] of Object.entries(c)) {
    vars[`--shl-color-${key.replace(/([A-Z])/g, "-$1").toLowerCase()}`] = value;
  }
  for (const [key, value] of Object.entries(spacing)) {
    vars[`--shl-spacing-${key}`] = value;
  }
  return vars;
 }
@@ -0,0 +1,18 @@
 {
  "compilerOptions": {
    "target": "ES2020",
    "lib": ["dom", "dom.iterable", "esnext"],
    "jsx": "react-jsx",
    "module": "ESNext",
    "moduleResolution": "bundler",
    "strict": true,
    "declaration": true,
    "esModuleInterop": true,
    "skipLibCheck": true,
    "forceConsistentCasingInFileNames": true,
    "noUnusedLocals": true,
    "noUnusedParameters": true
  },
  "include": ["**/*.ts", "**/*.tsx"],
  "exclude": ["node_modules"]
 }
@@ -0,0 +1,8 @@
 import { defineConfig } from "vitest/config";
 export default defineConfig({
  test: {
    environment: "jsdom",
    setupFiles: ["./vitest.setup.ts"],
  },
 });
@@ -0,0 +1,9 @@
 import "@testing-library/jest-dom/vitest";
 import { afterEach } from "vitest";
 import { cleanup } from "@testing-library/react";
 // Ohne explizites Cleanup bleiben zwischen den it()-Blöcken gerenderte Dialoge im DOM stehen
 // (mehrere <html>/<body>-Bäume stapeln sich), wodurch getByRole() mehrere Treffer statt einen findet.
 afterEach(() => {
  cleanup();
 });
@@ -0,0 +1,30 @@
 import { ThemeProvider, I18nProvider, ToastProvider, typography } from "@nexarch/shl";
 export const metadata = {
  title: "NEXARCH Systemstatus",
 };
 export default function RootLayout({
  children,
 }: {
  children: React.ReactNode;
 }) {
  return (
    <html lang="de">
      <body
        style={{
          fontFamily: typography.fontFamily,
          margin: 0,
          background: "var(--shl-color-background, #ffffff)",
          color: "var(--shl-color-text-primary, #14181f)",
        }}
      >
        <ThemeProvider>
          <I18nProvider initialLocale="de">
            <ToastProvider>{children}</ToastProvider>
          </I18nProvider>
        </ThemeProvider>
      </body>
    </html>
  );
 }
@@ -0,0 +1,125 @@
 "use client";
 import { useEffect, useState } from "react";
 import { fetchOverview, fetchHistory, type ModuleStatus, type HistoryEntry } from "@/lib/api";
 const POLL_INTERVAL_MS = 5000;
 export default function Page() {
  const [modules, setModules] = useState<ModuleStatus[]>([]);
  const [error, setError] = useState<string | null>(null);
  const [selected, setSelected] = useState<string | null>(null);
  const [history, setHistory] = useState<HistoryEntry[] | null>(null);
  const [historyError, setHistoryError] = useState<string | null>(null);
  useEffect(() => {
    let cancelled = false;
    async function poll() {
      try {
        const data = await fetchOverview();
        if (!cancelled) {
          setModules(data);
          setError(null);
        }
      } catch (e: any) {
        // Ein nicht antwortendes Backend darf die zuletzt bekannte Ansicht
        // nicht loeschen und die Seite nicht unbedienbar machen
        // (Akzeptanzkriterium 2) — nur eine Fehlermeldung anzeigen, alte
        // Daten bleiben sichtbar.
        if (!cancelled) {
          setError(e.message ?? "Unbekannter Fehler beim Laden der Uebersicht");
        }
      }
    }
    poll();
    const id = setInterval(poll, POLL_INTERVAL_MS);
    return () => {
      cancelled = true;
      clearInterval(id);
    };
  }, []);
  async function openHistory(name: string) {
    setSelected(name);
    setHistoryError(null);
    try {
      const data = await fetchHistory(name);
      setHistory(data);
    } catch (e: any) {
      setHistoryError(e.message ?? "Verlauf konnte nicht geladen werden");
      setHistory(null);
    }
  }
  const anyDown = modules.some((m) => m.status === "down");
  return (
    <main style={{ maxWidth: 800, margin: "0 auto", padding: "2rem 1rem" }}>
      <h1>Systemstatus</h1>
      {error && (
        <p style={{ color: "#c62828", background: "#fdecea", padding: "0.5rem", borderRadius: 4 }} role="alert">
          Uebersicht konnte gerade nicht aktualisiert werden: {error}. Zuletzt bekannter Stand wird weiter angezeigt.
        </p>
      )}
      {!error && anyDown && (
        <p style={{ color: "#c62828", background: "#fdecea", padding: "0.5rem", borderRadius: 4 }}>
          Mindestens ein Modul ist derzeit nicht erreichbar.
        </p>
      )}
      <ul style={{ listStyle: "none", padding: 0 }}>
        {modules.map((m) => (
          <li
            key={m.name}
            style={{
              display: "flex",
              justifyContent: "space-between",
              alignItems: "center",
              background: "white",
              padding: "0.75rem 1rem",
              marginBottom: "0.5rem",
              borderRadius: 8,
              borderLeft: `6px solid ${m.status === "up" ? "#2e7d32" : "#c62828"}`,
            }}
          >
            <div>
              <strong>{m.name}</strong>
              <div style={{ fontSize: "0.85rem", color: "#666" }}>
                {m.status === "up" ? "Verfügbar" : "Nicht verfügbar"}
                {m.last_checked && ` — zuletzt geprüft ${new Date(m.last_checked).toLocaleString("de-DE")}`}
              </div>
            </div>
            <button onClick={() => openHistory(m.name)}>Verlauf</button>
          </li>
        ))}
        {modules.length === 0 && !error && <li>Lade Modulstatus…</li>}
      </ul>
      {selected && (
        <section style={{ background: "white", padding: "1rem", borderRadius: 8, marginTop: "1.5rem" }}>
          <h2>Verlauf: {selected}</h2>
          {historyError && (
            <p style={{ color: "#c62828" }} role="alert">
              {historyError}
            </p>
          )}
          {history && (
            <ul>
              {history.map((h, i) => (
                <li key={i}>
                  {new Date(h.changed_at).toLocaleString("de-DE")} — {h.status === "up" ? "verfügbar" : "nicht verfügbar"}
                </li>
              ))}
              {history.length === 0 && <li>Keine Statusänderungen bisher.</li>}
            </ul>
          )}
          <button onClick={() => setSelected(null)}>Schließen</button>
        </section>
      )}
    </main>
  );
 }
@@ -0,0 +1,44 @@
 // Duenner Client des OPS-02-Backends (internal/statuspage) — keine eigene
 // Aggregations-/Polling-Logik im Frontend.
 export type ModuleStatus = {
  name: string;
  status: "up" | "down";
  last_checked?: string;
 };
 export type HistoryEntry = {
  status: "up" | "down";
  changed_at: string;
 };
 function apiBase(): string {
  const base = process.env.NEXT_PUBLIC_STATUSPAGE_API_URL;
  if (!base) {
    throw new Error(
      "NEXT_PUBLIC_STATUSPAGE_API_URL ist nicht gesetzt (Umgebungsvariable erforderlich)"
    );
  }
  return base;
 }
 // fetchOverview holt den Status EINES Moduls unabhaengig vom Erfolg der
 // anderen — ein Netzwerkfehler beim Abruf der Gesamtuebersicht wird vom
 // Aufrufer (Page-Komponente) abgefangen, sodass ein nicht antwortendes
 // Backend die Seite nicht zum Absturz bringt (Akzeptanzkriterium 2).
 export async function fetchOverview(): Promise<ModuleStatus[]> {
  const res = await fetch(`${apiBase()}/status/overview`, { cache: "no-store" });
  if (!res.ok) {
    throw new Error(`Uebersicht konnte nicht geladen werden (${res.status})`);
  }
  return res.json();
 }
 export async function fetchHistory(name: string): Promise<HistoryEntry[]> {
  const res = await fetch(`${apiBase()}/status/history?name=${encodeURIComponent(name)}`, {
    cache: "no-store",
  });
  if (!res.ok) {
    throw new Error(`Verlauf konnte nicht geladen werden (${res.status})`);
  }
  return res.json();
 }
@@ -0,0 +1,7 @@
 /** @type {import('next').NextConfig} */
 const nextConfig = {
  // @nexarch/shl liegt als file:-Dependency mit TS-Quellen in node_modules —
  // Next.js transpiliert node_modules standardmäßig nicht, siehe web/shl/README.md.
  transpilePackages: ["@nexarch/shl"],
 };
 export default nextConfig;
@@ -0,0 +1,22 @@
 {
  "name": "nexarch-status-page",
  "private": true,
  "scripts": {
    "dev": "next dev",
    "build": "next build",
    "start": "next start",
    "lint": "next lint"
  },
  "dependencies": {
    "@nexarch/shl": "file:../shl",
    "next": "14.2.35",
    "react": "18.3.1",
    "react-dom": "18.3.1"
  },
  "devDependencies": {
    "@types/node": "20.14.9",
    "@types/react": "18.3.3",
    "@types/react-dom": "18.3.0",
    "typescript": "5.5.3"
  }
 }
@@ -0,0 +1,21 @@
 {
  "compilerOptions": {
    "target": "es2017",
    "lib": ["dom", "dom.iterable", "esnext"],
    "allowJs": true,
    "skipLibCheck": true,
    "strict": true,
    "noEmit": true,
    "esModuleInterop": true,
    "module": "esnext",
    "moduleResolution": "bundler",
    "resolveJsonModule": true,
    "isolatedModules": true,
    "jsx": "preserve",
    "incremental": true,
    "plugins": [{ "name": "next" }],
    "paths": { "@/*": ["./*"] }
  },
  "include": ["next-env.d.ts", "**/*.ts", "**/*.tsx", ".next/types/**/*.ts"],
  "exclude": ["node_modules"]
 }
Author	SHA1	Message	Date
sysops	49a48743f5	Merge branch 'feature/shl-01-ui-shell-design-system-zentral' into feature/ops-02-zentrale-statusseite	2026-08-28 22:02:02 +02:00
sysops	bfa5c61db5	SHL-01: fix — Test-Cleanup zwischen Dialog-Tests (afterEach(cleanup), sonst stapeln sich gerenderte DOM-Bäume)	2026-08-28 22:01:56 +02:00
sysops	11940e28e6	OPS-02: fix — transpilePackages fuer @nexarch/shl (Next.js transpiliert node_modules sonst nicht, Build brach ab)	2026-08-28 21:56:39 +02:00
sysops	f7bc927d50	Merge branch 'feature/shl-01-ui-shell-design-system-zentral' into feature/ops-02-zentrale-statusseite	2026-08-28 21:56:31 +02:00
sysops	3c226dab12	SHL-01: fix — vitest jsdom-environment + jest-dom-Setup (3 Dialog-Tests schlugen ohne DOM fehl)	2026-08-28 21:55:34 +02:00
sysops	0f1add0b78	OPS-02: Retrofit auf SHL-01 (ThemeProvider/I18nProvider/ToastProvider, Design-Tokens statt hartkodierter Werte)	2026-08-28 21:47:48 +02:00
sysops	265c09db24	Merge branch 'feature/shl-01-ui-shell-design-system-zentral' into feature/ops-02-zentrale-statusseite # Conflicts: # DEVLOG.md	2026-08-28 21:47:32 +02:00
sysops	584cefa388	DEVLOG: Sessionlog-Eintrag (Auto-Hook)	2026-08-28 21:45:55 +02:00
sysops	00665592f6	SHL-01: ui-shell-design-system-zentral (tokens, theming, i18n-rahmen, basis-komponenten)	2026-08-28 21:41:56 +02:00
sysops	cabcabda8d	OPS-02: test-fix — overview-pruefung nur fuer eigene testziele, nicht alle jemals registrierten	2026-08-28 08:29:27 +02:00
sysops	81ebdd892b	OPS-02: dev-server + next.js zentrale statusseite	2026-08-28 08:21:27 +02:00
sysops	dff760e1ba	OPS-02: zentrale-statusseite (backend: poller + aggregierte uebersicht + verlauf)	2026-08-28 08:19:40 +02:00
		`@@ -0,0 +1,2 @@`
							`DROP TABLE status_history;`
							`DROP TABLE status_targets;`