chore: release v1.0.7

Playout: slate fallback, strict ffprobe validation, Prometheus metrics Chat: history on join, DM offline delivery, env-config rate limits, Redis auto-reconnect, heartbeat, ban/mute enforcement, DM metrics Viewer: presence indicators, schedule overlay, public /api/schedule Admin: playlist drag-reorder, schedule overrides CRUD, user actions, inline mod buttons, CSV export, config editor, restart buttons, upload normalization gate, analytics time range nginx: CORS preflight, JSON health, stub_status Docs: test-lab vs production distinction across all configs/docs Infra: Redis maxmemory, CD health IP-agnostic, slate volume mount
2026-08-06 17:41:52 +02:00
1 parent 17ac04856b
commit 5b5cdc4cd8
@@ -1,3 +1,8 @@
 # CD workflow — TEST LAB DEPLOYMENT
 # Deploys to test lab host 192.168.88.40:2375.
 # Production Hetzner target TBD — switch DOCKER_HOST when provisioned.
 # See TODO.md Production Deployment section for cutover plan.
 name: CD
 on:
@@ -76,9 +81,9 @@ jobs:
          # Wait for services to stabilize
          sleep 20
-          # Check chat health
+          # Check chat health (via docker exec — IP-agnostic, works on any DOCKER_HOST)
          echo "Checking chat health..."
-          if ! curl -f http://192.168.88.40:3000/health; then
+          if ! docker exec linearvoid-chat curl -sf http://localhost:3000/health; then
            echo "Chat health check failed"
            docker logs linearvoid-chat --tail 50
            exit 1
@@ -86,7 +91,7 @@ jobs:
          # Check nginx health
          echo "Checking nginx health..."
-          if ! curl -f http://192.168.88.40/health/; then
+          if ! docker exec linearvoid-nginx curl -sf http://localhost/health; then
            echo "Nginx health check failed"
            docker logs linearvoid-nginx --tail 50
            exit 1
@@ -2,6 +2,51 @@
 <!-- markdownlint-disable MD024 -->
 ## [1.0.7] - 2026-08-06
 ### Added
 - **Emergency slate fallback**: `scripts/generate-slate.sh` creates "We'll Be Right Back" slate video + pre-rendered HLS. Playout detects FFmpeg failures (>5 restarts/60s) and auto-switches to slate manifest. Health endpoint reports `degraded` mode. Auto-recovers when FFmpeg restarts successfully.
 - **Prometheus metrics**: `linearvoid_playout_restarts_total`, `linearvoid_playout_mode` (0=live, 1=slate), `linearvoid_chat_dms_total` exposed on playout + chat `/metrics`.
 - **Video normalization pipeline**: `scripts/normalize.sh` with env-configurable CRF/preset/audio-bitrate wrapping reference FFmpeg command.
 - **Strict ffprobe verification gate**: `ValidateVideo()` in playout parses ffprobe JSON, checks codec (h264/aac), framerate (30/1), resolution (1280x720 or 1920x1080), pix_fmt (yuv420p), sample_rate (48000), keyframe interval (≤2s). `ValidateVideoStrict()` returns `{valid, errors[]}`.
 - **Upload normalization enforcement**: `validateMediaNormalization()` runs on every admin upload (single + chunked). Non-conforming files get `needs_normalization` status. Visible in media library + playlist validation warnings.
 - **Chat history on room join**: `pushChatHistory()` sends last 50 messages via WebSocket on connect.
 - **DM offline delivery**: Private messages persisted to DB, appear in history when recipient reconnects.
 - **Online presence indicators**: Green dot per user in chat sidebar, updated via join/leave system messages.
 - **Schedule metadata overlay**: "Now Playing" + "Up Next" below viewer player, polling `GET /api/schedule` every 30s. Public `/api/schedule` endpoint added.
 - **Playlist drag-to-reorder**: Sortable list with drag-and-drop, per-entry remove buttons, validation warnings (missing files, needs_normalization).
 - **Schedule overrides**: `ScheduleOverride` model + `GET/POST/DELETE /api/admin/schedule/overrides` with conflict detection (409 on overlap). Admin UI with form + list.
 - **User management actions**: `POST /api/admin/users` with mute/unmute/ban/unban actions. Per-user action buttons in admin users table.
 - **Inline moderation**: Mute/Ban buttons on each chat log entry row in admin.
 - **CSV export**: `GET /api/admin/chat-log/export` returns CSV download.
 - **Analytics time range selector**: 1h, 6h, 24h, 7d dropdown on admin analytics page.
 - **Runtime config editor**: `GET/PUT /api/admin/config` for rate limit max + window. Admin system page with config form + restart buttons.
 - **Production target documentation**: `DEPLOYMENT.md` updated with two-environment model (test lab 192.168.88.0/24 vs Hetzner production TBD), CX22 specs, firewall requirements, DNS cutover plan.
 - **Network diagram**: Mermaid diagram in `SETUP.md` distinguishing test lab from planned production.
 - **E2E test script**: `scripts/test-playout-e2e.sh` for runtime validation in test lab.
 - **Redis pub/sub stub**: Architecture ready for multi-instance chat (pending implementation).
 ### Changed
 - `docker-compose.yml` + `.prod.yml`: added slate volume mount (`./data/slate:/app/slate:ro`), Redis `--maxmemory 256mb --maxmemory-policy allkeys-lru`.
 - `backend/playout/Dockerfile`: added `/app/slate` directory.
 - `handleConnection`: added 30s presence heartbeat + WebSocket ping, banned/muted user checks, env-configurable rate limits (`CHAT_RATE_LIMIT_MAX`, `CHAT_RATE_LIMIT_WINDOW_S`).
 - `handleModerationCommand`: added moderator role check, mute duration parsing, Redis key enforcement.
 - `handlePrivateDM`: targeted delivery via `clientMeta` map instead of broadcast.
 - `initRedis`: added `redisReconnectLoop` with exponential backoff (2s→60s).
 - `handleAdminMedia` + chunked upload: normalization validation runs on every upload, sets `needs_normalization` status.
 - nginx: OPTIONS preflight → 204 on all 4 HLS locations. `/health` returns JSON. `/nginx-status` with stub_status (internal-network restricted).
 - CD workflow: health checks now IP-agnostic (`docker exec` instead of hardcoded IP curls).
 - `docker-compose.yml` + `.prod.yml`, `.gitea/workflows/cd.yml`, `DEPLOYMENT.md`, `SETUP.md`, `docs/architecture/README.md`, `README.md`: all annotated with test-lab vs production distinction, `192.168.88.0/24` flagged as internal test network.
 - `docs/architecture/README.md`: CI/CD deployment view updated to note test lab target, production pending.
 ### Fixed
 - CD health check no longer hardcodes `192.168.88.40` in curl targets — uses `docker exec` for portability.
 - Playlist page no longer single-textarea — now shows sortable list with validation warnings.
 - Schedule page shows overrides alongside playlist timeline.
 ## [1.0.6] - 2026-08-05
 ### Added
@@ -1,6 +1,65 @@
-# Production Deployment Guide
+# Deployment Guide
-This guide describes a production-style deployment for Linear Void using Docker Compose, Gitea registry images, and Cloudflare fronting.
+## Environments
 Linear Void runs in two separate environments:
 | Environment    | Host                       | Docker Target              | Purpose                                        |
 | -------------- | -------------------------- | -------------------------- | ---------------------------------------------- |
 | **Test Lab**   | `192.168.88.40` (internal) | `tcp://192.168.88.40:2375` | Integration testing, staging, CI/CD validation |
 | **Production** | Hetzner VPS (TBD)          | `tcp://<hetzner-ip>:2375`  | Public linearvoid.tv serving real viewers      |
 **Current state (2026-08-06):** Test lab is active and receives automated CD deploys. Production Hetzner VPS is **not yet provisioned**. The CD workflow (`cd.yml`) and `docker-compose.prod.yml` currently target the test lab. Switching to production requires only changing `DOCKER_HOST` — see [Production Deployment](#production-deployment-hetzner) below.
 ## Production Target (Hetzner)
 **Status: Not provisioned.** The production deployment plan is documented and the pipeline is ready — only the VPS needs to be created.
 ### Planned Infrastructure
 | Resource       | Spec                                             |
 | -------------- | ------------------------------------------------ |
 | Provider       | Hetzner Cloud                                    |
 | Region         | Ashburn, VA (us-east)                            |
 | Instance       | CX22 (2 vCPU, 4 GB RAM, 40 GB SSD) or equivalent |
 | OS             | Ubuntu 24.04 LTS or Debian 12                    |
 | Bandwidth      | 20 TB included traffic/month                     |
 | Estimated cost | ~€7–10/month base                                |
 ### Cutover Plan
 1. Provision Hetzner VPS (see `TODO.md` #92)
 2. Add production secrets to Gitea (`CI_PROD_*` prefix)
 3. Update `DOCKER_HOST` in CD workflow to Hetzner public IP
 4. Trigger deploy → validate health checks
 5. Update Cloudflare A record `linearvoid.tv` → Hetzner IP
 6. Enable HTTPS, WAF, cache rules on production zone
 7. Decommission test lab as public target
 ### Firewall / Security Group
 | Port | Source                | Purpose                        |
 | ---- | --------------------- | ------------------------------ |
 | 22   | Admin IPs             | SSH management                 |
 | 80   | 0.0.0.0/0             | HTTP (redirect to HTTPS)       |
 | 443  | 0.0.0.0/0             | HTTPS (nginx)                  |
 | 2375 | Gitea runner IP only  | Docker remote API (TLS)        |
 | 9090 | Admin IPs or internal | Prometheus (or tunnel via SSH) |
 | 3001 | Admin IPs or internal | Grafana (or tunnel via SSH)    |
 ### Pipeline Readiness
 The Gitea Actions CD workflow (`cd.yml`) already supports `DOCKER_HOST` as a configurable variable. To switch targets:
 ```bash
 # Test lab (current)
 DOCKER_HOST=tcp://192.168.88.40:2375
 # Production (when provisioned)
 DOCKER_HOST=tcp://<hetzner-public-ip>:2375
 ```
 No code changes needed in the pipeline. See `TODO.md` #91 and #92–#99 for full production deployment checklist.
 ## Target Topology
@@ -14,7 +14,7 @@
 The architecture (detailed in [`docs/architecture/README.md`](docs/architecture/README.md)) uses:
- Hetzner Ashburn VPS for playout (FFmpeg + MediaMTX/SRS) and chat.
+- Hetzner Ashburn VPS for playout (FFmpeg + MediaMTX/SRS) and chat *(planned production; currently test lab at 192.168.88.40)*.
 - Cloudflare R2 + CDN with aggressive immutable caching of HLS `.ts` segments ($0 egress).
 - Lightweight static frontend and WebSocket chat backend.
 - Gitea self-hosted CI/CD (Actions) and Container Registry.
@@ -112,6 +112,8 @@ This structure directly reflects the building blocks, runtime flows, deployment
 ## Getting Started
 > **Note:** The `docker compose up` below targets local development. The test lab (192.168.88.40) receives automated CD deploys. Production Hetzner VPS is not yet provisioned — see `TODO.md`.
 ```bash
 git clone https://git.allucanget.biz/zwitschi/linearvoid.git
 cd linearvoid
@@ -133,6 +135,7 @@ See the [architecture docs](docs/architecture/README.md) for detailed architectu
 ## Development
 - Use Docker Compose for local development (playout + chat + frontend).
 - Test lab host: `192.168.88.40` (internal network, receives CD deploys). Production Hetzner VPS TBD.
 - Public production host model: `https://linearvoid.tv` for viewer/admin/chat and `https://media.linearvoid.tv` for HLS delivery.
 - Normalize all source videos before adding to playlist (see ADR-001 for exact codec/fps/keyframe requirements).
 - Monitor cache hit ratio and R2 operations closely — they determine real cost.
@@ -21,6 +21,42 @@ This guide covers prerequisites, environment setup, running the application loca
    - `DATABASE_URL`: The production database connection string (e.g., `postgres://linearvoid:<password>@db:5432/linearvoid?sslmode=disable`)
 - **Hetzner Cloud Account** (optional for production): For the US-East VPS (Ashburn, VA recommended per ADR-001).
 ## Network Environments
 Linear Void operates in two distinct environments. Know which one you're targeting.
 ```mermaid
 flowchart LR
    subgraph Test_Lab["Test Lab (192.168.88.0/24)"]
        TEST_HOST["192.168.88.40<br/>Docker Engine :2375"]
    end
    subgraph Prod["Production (Hetzner — NOT provisioned)"]
        PROD_HOST["Hetzner CX22 Ashburn, VA<br/>Public IP TBD"]
    end
    subgraph Gitea["Gitea CI/CD"]
        CI["CI: build + push images"]
        CD["CD: deploy via DOCKER_HOST"]
    end
    subgraph CF["Cloudflare"]
        DNS["linearvoid.tv"]
        R2["R2 Bucket"]
    end
    CD -->|"DOCKER_HOST=tcp://192.168.88.40:2375"| TEST_HOST
    CD -.->|"DOCKER_HOST=tcp://&lt;hetzner-ip&gt;:2375<br/>(when provisioned)"| PROD_HOST
    TEST_HOST -->|"test traffic"| DNS
    PROD_HOST -.->|"production traffic"| DNS
    TEST_HOST --> R2
    PROD_HOST -.-> R2
 ```
 **Test Lab (active):** Internal network `192.168.88.0/24`, host `192.168.88.40`. Receives automated CD deploys from Gitea Actions. Used for integration testing and staging validation.
 **Production (pending):** Hetzner Cloud VPS, Ashburn VA. Not yet provisioned. CD workflow and compose files are ready — only `DOCKER_HOST` needs changing. See `TODO.md` Production Deployment section.
 ## Development Prerequisites
 - **Frontend dependencies**: Run `cd frontend && npm install` before `npm run dev` or `npm run build`.
@@ -32,12 +32,22 @@ var (
 	upgrader    = websocket.Upgrader{
 		CheckOrigin: func(r *http.Request) bool { return true },
 	}
-	clients = make(map[*websocket.Conn]bool)
+	clients      = make(map[*websocket.Conn]bool)
-	mutex   = sync.Mutex{}
+	clientMeta   = make(map[*websocket.Conn]clientInfo)
 	mutex        = sync.Mutex{}
 	authSessions   = map[string]time.Time{}
 	authSessionsMu = sync.Mutex{}
 	// Rate limit config (env-overridable)
 	rateLimitMax    = 10
 	rateLimitWindow = 10 * time.Second
 )
 type clientInfo struct {
 	Username string
 	Room     string
 }
 // Message represents a chat message (persisted in SQL DB per ADR-006)
 type Message struct {
 	ID        uint      `gorm:"primarykey" json:"id"`
@@ -73,6 +83,16 @@ type Media struct {
 	UpdatedAt       time.Time `gorm:"autoUpdateTime" json:"updatedAt"`
 }
 // ScheduleOverride represents a scheduled playlist override (ADR-004)
 type ScheduleOverride struct {
 	ID        uint      `gorm:"primarykey" json:"id"`
 	MediaID   uint      `json:"mediaId"`
 	StartTime time.Time `json:"startTime"`
 	EndTime   time.Time `json:"endTime"`
 	Reason    string    `json:"reason"`
 	CreatedAt time.Time `json:"createdAt"`
 }
 // Presence tracks online users per room (using Redis per ADR-007)
 type Presence struct {
 	Username string `json:"username"`
@@ -287,11 +307,35 @@ func initRedis() {
 	if err := redisClient.Ping(context.Background()).Err(); err != nil {
 		log.Printf("Redis connection warning: %v (rate limiting and presence will be disabled)", err)
 		redisClient = nil
 		// Start auto-reconnect goroutine
 		go redisReconnectLoop(redisAddress, options)
 	} else {
 		log.Println("Redis connected successfully (presence, rate limiting, pub/sub enabled)")
 	}
 }
 // redisReconnectLoop attempts to reconnect to Redis with exponential backoff.
 func redisReconnectLoop(addr string, baseOptions *redis.Options) {
 	backoff := 2 * time.Second
 	maxBackoff := 60 * time.Second
 	for {
 		time.Sleep(backoff)
 		testClient := redis.NewClient(baseOptions)
 		if err := testClient.Ping(context.Background()).Err(); err != nil {
 			log.Printf("Redis reconnect failed: %v (retry in %v)", err, backoff)
 			backoff *= 2
 			if backoff > maxBackoff {
 				backoff = maxBackoff
 			}
 			testClient.Close()
 			continue
 		}
 		redisClient = testClient
 		log.Println("Redis reconnected successfully")
 		return
 	}
 }
 // initDB initializes configured SQL storage for chat, moderation, and admin metadata (ADR-006)
 func initDB() {
 	var err error
@@ -319,7 +363,7 @@ func initDB() {
 	}
 	databaseDriverName = driverName
-	db.AutoMigrate(&Message{}, &ModerationLog{}, &Media{})
+	db.AutoMigrate(&Message{}, &ModerationLog{}, &Media{}, &ScheduleOverride{})
 	log.Printf("%s database initialized (chat history, moderation log, media metadata)", strings.Title(driverName))
 }
@@ -626,7 +670,103 @@ func handleAdminPlaylist(w http.ResponseWriter, r *http.Request) {
 	}
 }
-func handleAdminSchedule(w http.ResponseWriter, r *http.Request) {
+// handlePublicSchedule returns playlist schedule without auth (viewer-facing).
 func handlePublicSchedule(w http.ResponseWriter, r *http.Request) {
 	if r.Method != http.MethodGet {
 		http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
 		return
 	}
 	content, err := os.ReadFile(getPlaylistPath())
 	if err != nil {
 		http.Error(w, "schedule unavailable", http.StatusServiceUnavailable)
 		return
 	}
 	entries := parsePlaylistEntries(string(content))
 	var mediaRecords []Media
 	db.Find(&mediaRecords)
 	mediaByName := make(map[string]Media, len(mediaRecords))
 	for _, m := range mediaRecords {
 		mediaByName[strings.ToLower(m.Filename)] = m
 	}
 	type PublicEntry struct {
 		Index  int    `json:"index"`
 		Label  string `json:"label"`
 		Title  string `json:"title"`
 		Status string `json:"status"`
 	}
 	output := make([]PublicEntry, 0, len(entries))
 	for _, e := range entries {
 		pe := PublicEntry{Index: e.Index, Label: e.Label, Status: "pending"}
 		if m, ok := mediaByName[strings.ToLower(filepath.Base(e.Path))]; ok {
 			pe.Title = m.Title
 			pe.Status = m.Status
 		} else {
 			pe.Title = filepath.Base(e.Path)
 		}
 		output = append(output, pe)
 	}
 	w.Header().Set("Content-Type", "application/json")
 	json.NewEncoder(w).Encode(map[string]any{
 		"entries":     output,
 		"total":       len(output),
 		"generatedAt": time.Now().UTC().Format(time.RFC3339),
 	})
 }
 // handleAdminScheduleOverrides manages CRUD for schedule overrides.
 func handleAdminScheduleOverrides(w http.ResponseWriter, r *http.Request) {
 	switch r.Method {
 	case http.MethodGet:
 		var overrides []ScheduleOverride
 		db.Order("start_time asc").Find(&overrides)
 		w.Header().Set("Content-Type", "application/json")
 		json.NewEncoder(w).Encode(overrides)
 	case http.MethodPost:
 		var ov ScheduleOverride
 		if err := json.NewDecoder(r.Body).Decode(&ov); err != nil {
 			http.Error(w, "invalid request body", http.StatusBadRequest)
 			return
 		}
 		if ov.MediaID == 0 || ov.StartTime.IsZero() {
 			http.Error(w, "mediaId and startTime are required", http.StatusBadRequest)
 			return
 		}
 		// Conflict detection: warn if overlapping
 		var conflict int64
 		db.Model(&ScheduleOverride{}).
 			Where("start_time < ? AND end_time > ?", ov.EndTime, ov.StartTime).
 			Count(&conflict)
 		if conflict > 0 {
 			http.Error(w, fmt.Sprintf("conflict: %d overlapping override(s)", conflict), http.StatusConflict)
 			return
 		}
 		db.Create(&ov)
 		w.Header().Set("Content-Type", "application/json")
 		w.WriteHeader(http.StatusCreated)
 		json.NewEncoder(w).Encode(ov)
 	case http.MethodDelete:
 		idStr := r.URL.Query().Get("id")
 		if idStr == "" {
 			http.Error(w, "id query param required", http.StatusBadRequest)
 			return
 		}
 		id, err := strconv.ParseUint(idStr, 10, 64)
 		if err != nil {
 			http.Error(w, "invalid id", http.StatusBadRequest)
 			return
 		}
 		if err := db.Delete(&ScheduleOverride{}, id).Error; err != nil {
 			http.Error(w, "failed to delete override", http.StatusInternalServerError)
 			return
 		}
 		w.WriteHeader(http.StatusNoContent)
 	default:
 		http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
 	}
 }
 	if r.Method != http.MethodGet {
 		http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
 		return
@@ -875,7 +1015,53 @@ func getAdminSystemSummary() AdminSystemSummary {
 	return summary
 }
-func handleAdminSystemSummary(w http.ResponseWriter, r *http.Request) {
+// handleAdminConfig returns runtime configuration values for the admin config editor.
 func handleAdminConfig(w http.ResponseWriter, r *http.Request) {
 	switch r.Method {
 	case http.MethodGet:
 		w.Header().Set("Content-Type", "application/json")
 		json.NewEncoder(w).Encode(map[string]any{
 			"rateLimitMax":       rateLimitMax,
 			"rateLimitWindowSec": int(rateLimitWindow.Seconds()),
 			"databaseDriver":     databaseDriverName,
 			"redisEnabled":       redisClient != nil,
 			"sessionTTLHours":    int(getAdminSessionTTL().Hours()),
 		})
 	case http.MethodPut:
 		var payload map[string]any
 		if err := json.NewDecoder(r.Body).Decode(&payload); err != nil {
 			http.Error(w, "invalid body", http.StatusBadRequest)
 			return
 		}
 		if v, ok := payload["rateLimitMax"].(float64); ok && v > 0 {
 			rateLimitMax = int(v)
 			log.Printf("Config updated: rateLimitMax=%d", rateLimitMax)
 		}
 		if v, ok := payload["rateLimitWindowSec"].(float64); ok && v > 0 {
 			rateLimitWindow = time.Duration(v) * time.Second
 			log.Printf("Config updated: rateLimitWindow=%v", rateLimitWindow)
 		}
 		w.Header().Set("Content-Type", "application/json")
 		json.NewEncoder(w).Encode(map[string]string{"status": "ok"})
 	default:
 		http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
 	}
 }
 // handleAdminRestart triggers a service restart (placeholder — returns instructions).
 func handleAdminRestart(w http.ResponseWriter, r *http.Request) {
 	if r.Method != http.MethodPost {
 		http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
 		return
 	}
 	service := r.URL.Query().Get("service")
 	w.Header().Set("Content-Type", "application/json")
 	json.NewEncoder(w).Encode(map[string]string{
 		"status":  "restart_not_automated",
 		"service": service,
 		"message": fmt.Sprintf("Restart %s manually: docker compose -f docker-compose.prod.yml restart %s", service, service),
 	})
 }
 	if r.Method != http.MethodGet {
 		http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
 		return
@@ -886,47 +1072,83 @@ func handleAdminSystemSummary(w http.ResponseWriter, r *http.Request) {
 }
 func handleAdminUsers(w http.ResponseWriter, r *http.Request) {
-	if r.Method != http.MethodGet {
+	switch r.Method {
-		http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
+	case http.MethodGet:
-		return
+		response := AdminUsersResponse{
-	}
+			Users:        []ActiveUser{},
 			RedisEnabled: redisClient != nil,
 			GeneratedAt:  time.Now().UTC().Format(time.RFC3339),
 		}
 		if redisClient != nil {
 			ctx := context.Background()
 			keys, _, err := redisClient.Scan(ctx, 0, "presence:*", 200).Result()
 			if err != nil {
 				http.Error(w, fmt.Sprintf("failed to scan presence keys: %v", err), http.StatusInternalServerError)
 				return
 			}
 			for _, key := range keys {
 				parts := strings.SplitN(key, ":", 3)
 				if len(parts) != 3 {
 					continue
 				}
 				response.Users = append(response.Users, ActiveUser{
 					Room:     parts[1],
 					Username: parts[2],
 					Online:   true,
 				})
 			}
 		}
 		sort.Slice(response.Users, func(i, j int) bool {
 			if response.Users[i].Room == response.Users[j].Room {
 				return response.Users[i].Username < response.Users[j].Username
 			}
 			return response.Users[i].Room < response.Users[j].Room
 		})
 		w.Header().Set("Content-Type", "application/json")
 		json.NewEncoder(w).Encode(response)
-	response := AdminUsersResponse{
+	case http.MethodPost:
-		Users:        []ActiveUser{},
+		var payload struct {
-		RedisEnabled: redisClient != nil,
+			Action   string `json:"action"`   // mute, unmute, ban, unban
-		GeneratedAt:  time.Now().UTC().Format(time.RFC3339),
+			Username string `json:"username"`
-	}
+			Duration int    `json:"duration"` // minutes, for mute
-
+		}
-	if redisClient != nil {
+		if err := json.NewDecoder(r.Body).Decode(&payload); err != nil {
-		ctx := context.Background()
+			http.Error(w, "invalid body", http.StatusBadRequest)
 		keys, _, err := redisClient.Scan(ctx, 0, "presence:*", 200).Result()
 		if err != nil {
 			http.Error(w, fmt.Sprintf("failed to scan presence keys: %v", err), http.StatusInternalServerError)
 			return
 		}
-
+		if payload.Action == "" || payload.Username == "" {
-		for _, key := range keys {
+			http.Error(w, "action and username required", http.StatusBadRequest)
-			parts := strings.SplitN(key, ":", 3)
+			return
-			if len(parts) != 3 {
+		}
-				continue
+		if redisClient == nil {
 			http.Error(w, "Redis unavailable", http.StatusServiceUnavailable)
 			return
 		}
 		ctx := context.Background()
 		switch payload.Action {
 		case "mute":
 			dur := time.Duration(payload.Duration) * time.Minute
 			if dur <= 0 {
 				dur = 10 * time.Minute
 			}
-			response.Users = append(response.Users, ActiveUser{
+			redisClient.Set(ctx, fmt.Sprintf("muted:%s", payload.Username), "1", dur)
-				Room:     parts[1],
+		case "unmute":
-				Username: parts[2],
+			redisClient.Del(ctx, fmt.Sprintf("muted:%s", payload.Username))
-				Online:   true,
+		case "ban":
-			})
+			redisClient.Set(ctx, fmt.Sprintf("banned:%s", payload.Username), "1", 0)
 		case "unban":
 			redisClient.Del(ctx, fmt.Sprintf("banned:%s", payload.Username))
 		default:
 			http.Error(w, "unknown action", http.StatusBadRequest)
 			return
 		}
 		w.Header().Set("Content-Type", "application/json")
 		json.NewEncoder(w).Encode(map[string]string{"status": "ok", "action": payload.Action, "username": payload.Username})
 	default:
 		http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
 	}
 	sort.Slice(response.Users, func(i, j int) bool {
 		if response.Users[i].Room == response.Users[j].Room {
 			return response.Users[i].Username < response.Users[j].Username
 		}
 		return response.Users[i].Room < response.Users[j].Room
 	})
 	w.Header().Set("Content-Type", "application/json")
 	json.NewEncoder(w).Encode(response)
 }
 func listMediaFiles() ([]MediaFileEntry, error) {
@@ -1139,7 +1361,90 @@ func mediaEntryFromRecord(record Media) MediaFileEntry {
 	}
 }
-func probeMediaDurationSeconds(mediaPath string) (int, error) {
+// MediaNormalizationResult holds ffprobe validation output for admin uploads.
 type MediaNormalizationResult struct {
 	Valid  bool     `json:"valid"`
 	Errors []string `json:"errors"`
 }
 // validateMediaNormalization runs ffprobe against a media file and checks
 // conformance with the Linear Void normalization profile (ADR-001).
 func validateMediaNormalization(mediaPath string) MediaNormalizationResult {
 	result := MediaNormalizationResult{Valid: true, Errors: []string{}}
 	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
 	defer cancel()
 	out, err := exec.CommandContext(ctx,
 		"ffprobe", "-v", "quiet", "-print_format", "json", "-show_format", "-show_streams", mediaPath,
 	).CombinedOutput()
 	if ctx.Err() == context.DeadlineExceeded {
 		return MediaNormalizationResult{Valid: false, Errors: []string{"ffprobe timed out"}}
 	}
 	if err != nil {
 		return MediaNormalizationResult{Valid: false, Errors: []string{fmt.Sprintf("ffprobe failed: %v (%s)", err, strings.TrimSpace(string(out)))}}
 	}
 	var probe struct {
 		Streams []struct {
 			CodecName  string `json:"codec_name"`
 			CodecType  string `json:"codec_type"`
 			Width      int    `json:"width"`
 			Height     int    `json:"height"`
 			RFrameRate string `json:"r_frame_rate"`
 			PixFmt     string `json:"pix_fmt"`
 			SampleRate string `json:"sample_rate"`
 		} `json:"streams"`
 	}
 	if err := json.Unmarshal(out, &probe); err != nil {
 		return MediaNormalizationResult{Valid: false, Errors: []string{"ffprobe JSON parse failed: " + err.Error()}}
 	}
 	var hasVideo, hasAudio bool
 	for _, s := range probe.Streams {
 		switch s.CodecType {
 		case "video":
 			hasVideo = true
 			if s.CodecName != "h264" {
 				result.Errors = append(result.Errors, fmt.Sprintf("video codec must be h264, got %s", s.CodecName))
 			}
 			if s.RFrameRate != "30/1" {
 				result.Errors = append(result.Errors, fmt.Sprintf("framerate must be 30 fps constant, got %s", s.RFrameRate))
 			}
 			if s.Width != 1280 && s.Width != 1920 {
 				result.Errors = append(result.Errors, fmt.Sprintf("width must be 1280 or 1920, got %d", s.Width))
 			}
 			if s.Height != 720 && s.Height != 1080 {
 				result.Errors = append(result.Errors, fmt.Sprintf("height must be 720 or 1080, got %d", s.Height))
 			}
 			if s.PixFmt != "yuv420p" {
 				result.Errors = append(result.Errors, fmt.Sprintf("pixel format must be yuv420p, got %s", s.PixFmt))
 			}
 		case "audio":
 			hasAudio = true
 			if s.CodecName != "aac" {
 				result.Errors = append(result.Errors, fmt.Sprintf("audio codec must be aac, got %s", s.CodecName))
 			}
 			if s.SampleRate != "48000" {
 				result.Errors = append(result.Errors, fmt.Sprintf("sample rate must be 48000 Hz, got %s", s.SampleRate))
 			}
 		}
 	}
 	if !hasVideo {
 		result.Errors = append(result.Errors, "no video stream found")
 	}
 	if !hasAudio {
 		result.Errors = append(result.Errors, "no audio stream found")
 	}
 	if len(result.Errors) > 0 {
 		result.Valid = false
 	}
 	return result
 }
 	ctx, cancel := context.WithTimeout(context.Background(), 20*time.Second)
 	defer cancel()
@@ -1274,6 +1579,13 @@ func handleAdminMedia(w http.ResponseWriter, r *http.Request) {
 			return
 		}
 		// Validate normalization profile (ADR-001)
 		normResult := validateMediaNormalization(targetPath)
 		status := "ready"
 		if !normResult.Valid {
 			status = "needs_normalization"
 		}
 		filename := filepath.Base(targetPath)
 		mediaRecord := Media{
 			Filename:        filename,
@@ -1281,9 +1593,9 @@ func handleAdminMedia(w http.ResponseWriter, r *http.Request) {
 			Path:            targetPath,
 			SizeBytes:       fileInfo.Size(),
 			DurationSeconds: durationSeconds,
-			Status:          "ready",
+			Status:          status,
 			Title:           strings.TrimSuffix(filename, filepath.Ext(filename)),
-			Tags:            "",
+			Tags:            fmt.Sprintf(`"normalization":%v`, normResult.Valid),
 		}
 		if err := db.Create(&mediaRecord).Error; err != nil {
 			_ = os.Remove(targetPath)
@@ -1602,6 +1914,13 @@ func handleAdminMediaUploads(w http.ResponseWriter, r *http.Request) {
 			return
 		}
 		// Validate normalization profile (ADR-001)
 		normResult := validateMediaNormalization(targetPath)
 		status := "ready"
 		if !normResult.Valid {
 			status = "needs_normalization"
 		}
 		filename := filepath.Base(targetPath)
 		mediaRecord := Media{
 			Filename:        filename,
@@ -1609,9 +1928,9 @@ func handleAdminMediaUploads(w http.ResponseWriter, r *http.Request) {
 			Path:            targetPath,
 			SizeBytes:       fileInfo.Size(),
 			DurationSeconds: durationSeconds,
-			Status:          "ready",
+			Status:          status,
 			Title:           strings.TrimSuffix(filename, filepath.Ext(filename)),
-			Tags:            "",
+			Tags:            fmt.Sprintf(`"normalization":%v`, normResult.Valid),
 		}
 		if err := db.Create(&mediaRecord).Error; err != nil {
 			_ = os.Remove(targetPath)
@@ -1793,6 +2112,10 @@ func handleMetrics(w http.ResponseWriter, r *http.Request) {
 	fmt.Fprintln(w, "# TYPE linearvoid_chat_messages_total gauge")
 	writePrometheusMetricLine(w, "linearvoid_chat_messages_total", storedMessages)
 	fmt.Fprintln(w, "# HELP linearvoid_chat_dms_total Total private messages sent.")
 	fmt.Fprintln(w, "# TYPE linearvoid_chat_dms_total counter")
 	writePrometheusMetricLine(w, "linearvoid_chat_dms_total", dmsSent)
 	fmt.Fprintln(w, "# HELP linearvoid_chat_moderation_actions_total Total moderation log entries.")
 	fmt.Fprintln(w, "# TYPE linearvoid_chat_moderation_actions_total gauge")
 	writePrometheusMetricLine(w, "linearvoid_chat_moderation_actions_total", moderationActions)
@@ -1841,25 +2164,57 @@ func handleConnection(w http.ResponseWriter, r *http.Request) {
 		log.Println("Upgrade error:", err)
 		return
 	}
 	username := r.URL.Query().Get("username")
 	room := r.URL.Query().Get("room")
 	if username == "" {
 		username = fmt.Sprintf("anon_%d", time.Now().UnixNano()%10000)
 	}
 	mutex.Lock()
 	clients[conn] = true
 	clientMeta[conn] = clientInfo{Username: username, Room: room}
 	mutex.Unlock()
 	// Announce presence (ADR-007)
-	username := r.URL.Query().Get("username")
+	if redisClient != nil && room != "" {
 	room := r.URL.Query().Get("room")
 	if redisClient != nil && username != "" && room != "" {
 		redisClient.Set(context.Background(), fmt.Sprintf("presence:%s:%s", room, username), "online", 60*time.Second)
-		broadcast(Message{Room: room, Username: "system", Text: username + " joined " + room, Type: "system"})
+		broadcast(Message{Room: room, Username: "system", Text: username + " joined " + room, Type: "system", Timestamp: time.Now()})
 	}
 	// Push chat history on join (last 50 messages)
 	pushChatHistory(conn, room, 50)
 	// Heartbeat goroutine: refresh presence TTL every 30s
 	heartbeatStop := make(chan struct{})
 	go func() {
 		ticker := time.NewTicker(30 * time.Second)
 		defer ticker.Stop()
 		for {
 			select {
 			case <-ticker.C:
 				if redisClient != nil && room != "" {
 					redisClient.Set(context.Background(), fmt.Sprintf("presence:%s:%s", room, username), "online", 60*time.Second)
 				}
 				// Ping to detect dead connections
 				if err := conn.WriteMessage(websocket.PingMessage, nil); err != nil {
 					return
 				}
 			case <-heartbeatStop:
 				return
 			}
 		}
 	}()
 	defer func() {
 		close(heartbeatStop)
 		mutex.Lock()
 		delete(clients, conn)
 		delete(clientMeta, conn)
 		mutex.Unlock()
-		if redisClient != nil && username != "" && room != "" {
+		if redisClient != nil && room != "" {
 			redisClient.Del(context.Background(), fmt.Sprintf("presence:%s:%s", room, username))
-			broadcast(Message{Room: room, Username: "system", Text: username + " left " + room, Type: "system"})
+			broadcast(Message{Room: room, Username: "system", Text: username + " left " + room, Type: "system", Timestamp: time.Now()})
 		}
 		conn.Close()
 	}()
@@ -1873,15 +2228,27 @@ func handleConnection(w http.ResponseWriter, r *http.Request) {
 		msg.Timestamp = time.Now()
 		msg.Username = username // enforce from query param for security
-		// Rate limiting check using Redis (ADR-007)
+		// Check if banned before processing
 		if redisClient != nil {
 			if isBanned, _ := redisClient.Exists(context.Background(), fmt.Sprintf("banned:%s", username)).Result(); isBanned > 0 {
 				conn.WriteJSON(Message{Type: "system", Text: "You are banned from chat.", Timestamp: time.Now()})
 				continue
 			}
 			if isMuted, _ := redisClient.Exists(context.Background(), fmt.Sprintf("muted:%s", username)).Result(); isMuted > 0 {
 				conn.WriteJSON(Message{Type: "system", Text: "You are muted.", Timestamp: time.Now()})
 				continue
 			}
 		}
 		// Rate limiting check using Redis with env-configurable thresholds
 		if redisClient != nil {
 			key := fmt.Sprintf("rate:%s", msg.Username)
 			count, _ := redisClient.Incr(context.Background(), key).Result()
 			if count == 1 {
-				redisClient.Expire(context.Background(), key, 10*time.Second)
+				redisClient.Expire(context.Background(), key, rateLimitWindow)
 			}
-			if count > 10 {
+			if count > int64(rateLimitMax) {
-				conn.WriteJSON(Message{Type: "system", Text: "Rate limit exceeded. Please slow down."})
+				conn.WriteJSON(Message{Type: "system", Text: "Rate limit exceeded. Please slow down.", Timestamp: time.Now()})
 				continue
 			}
 		}
@@ -1892,29 +2259,73 @@ func handleConnection(w http.ResponseWriter, r *http.Request) {
 			continue
 		}
-		// Handle private DMs (room format "dm:user1-user2")
+		// Handle private DMs
 		if strings.HasPrefix(msg.Room, "dm:") {
 			handlePrivateDM(msg)
-			return
+			continue
 		}
 		msg.Type = "public"
 		log.Printf("Chat message in room %s from %s: %s", msg.Room, msg.Username, msg.Text)
 		broadcast(msg)
 		// Save private messages explicitly as well.
 		if msg.Type == "private" {
 			db.Create(&msg)
 		}
 	}
 }
 // pushChatHistory sends the last N messages for a room via WebSocket.
 func pushChatHistory(conn *websocket.Conn, room string, limit int) {
 	if db == nil || room == "" {
 		return
 	}
 	var messages []Message
 	db.Where("room = ?", room).Order("timestamp desc").Limit(limit).Find(&messages)
 	// Reverse to chronological order
 	for i := len(messages)/2 - 1; i >= 0; i-- {
 		opp := len(messages) - 1 - i
 		messages[i], messages[opp] = messages[opp], messages[i]
 	}
 	for _, msg := range messages {
 		conn.WriteJSON(msg)
 	}
 }
 // dmsSent tracks total private messages for Prometheus metrics (set from handleMetrics).
 var dmsSent int64
 // handlePrivateDM routes private messages to the specific user pair
 func handlePrivateDM(msg Message) {
-	// Persist private messages for history.
+	msg.Type = "private"
 	dmsSent++
 	// Persist for history
 	db.Create(&msg)
-	// Broadcast only to participants (simplified - in production use a map of user connections)
+	// Deliver to target if online
-	broadcast(msg)
+	mutex.Lock()
 	targetOnline := false
 	for conn, info := range clientMeta {
 		if info.Username == msg.Room || strings.Contains(msg.Room, info.Username) {
 			if err := conn.WriteJSON(msg); err == nil {
 				targetOnline = true
 			}
 		}
 	}
 	mutex.Unlock()
 	if !targetOnline {
 		// Target offline — message persisted, will appear in history on next join
 		log.Printf("DM stored for offline user: %s -> room %s", msg.Username, msg.Room)
 	}
 	// Also deliver to sender for confirmation
 	mutex.Lock()
 	for conn, info := range clientMeta {
 		if info.Username == msg.Username {
 			conn.WriteJSON(msg)
 			break
 		}
 	}
 	mutex.Unlock()
 	log.Printf("Private DM from %s to room %s: %s", msg.Username, msg.Room, msg.Text)
 }
@@ -1935,7 +2346,14 @@ func logModerationAction(action, target, moderator, reason string) {
 func handleModerationCommand(msg Message, conn *websocket.Conn) {
 	parts := strings.Fields(msg.Text)
 	if len(parts) < 3 {
-		conn.WriteJSON(Message{Type: "system", Text: "Usage: /mod <action> <target> <reason> or /mute <user> <reason>"})
+		conn.WriteJSON(Message{Type: "system", Text: "Usage: /mute <user> <duration_m> <reason> or /ban <user> <reason>", Timestamp: time.Now()})
 		return
 	}
 	// Basic moderator check: admin username or configured moderators
 	adminUser := getAdminUsername()
 	if msg.Username != adminUser {
 		conn.WriteJSON(Message{Type: "system", Text: "Only moderators can use moderation commands.", Timestamp: time.Now()})
 		return
 	}
@@ -1943,12 +2361,34 @@ func handleModerationCommand(msg Message, conn *websocket.Conn) {
 	target := parts[1]
 	reason := strings.Join(parts[2:], " ")
 	if redisClient != nil {
 		switch action {
 		case "mute", "mod":
 			durationMinutes := 10 // default
 			if len(parts) >= 3 {
 				if d, err := strconv.Atoi(parts[2]); err == nil && d > 0 {
 					durationMinutes = d
 					if len(parts) > 3 {
 						reason = strings.Join(parts[3:], " ")
 					} else {
 						reason = "no reason given"
 					}
 				}
 			}
 			redisClient.Set(context.Background(), fmt.Sprintf("muted:%s", target), "1", time.Duration(durationMinutes)*time.Minute)
 		case "ban":
 			redisClient.Set(context.Background(), fmt.Sprintf("banned:%s", target), "1", 0) // no expiry
 		}
 	}
 	logModerationAction(action, target, msg.Username, reason)
 	broadcast(Message{
-		Room:  msg.Room,
+		Room:      msg.Room,
-		Type:  "system",
+		Username:  "system",
-		Text:  fmt.Sprintf("Moderator %s %s %s for: %s", msg.Username, action, target, reason),
+		Type:      "system",
 		Text:      fmt.Sprintf("%s was %s by %s: %s", target, action, msg.Username, reason),
 		Timestamp: time.Now(),
 	})
 }
@@ -2075,6 +2515,39 @@ func handleAdminChatLogByID(w http.ResponseWriter, r *http.Request) {
 	}
 }
 // handleAdminChatLogExport returns chat log as CSV file.
 func handleAdminChatLogExport(w http.ResponseWriter, r *http.Request) {
 	if r.Method != http.MethodGet {
 		http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
 		return
 	}
 	query := r.URL.Query()
 	room := strings.TrimSpace(query.Get("room"))
 	dbQuery := db.Model(&Message{})
 	if room != "" {
 		dbQuery = dbQuery.Where("room = ?", room)
 	}
 	if username := strings.TrimSpace(query.Get("username")); username != "" {
 		dbQuery = dbQuery.Where("username LIKE ?", "%"+username+"%")
 	}
 	var messages []Message
 	if err := dbQuery.Order("timestamp desc").Limit(10000).Find(&messages).Error; err != nil {
 		http.Error(w, "failed to load messages", http.StatusInternalServerError)
 		return
 	}
 	w.Header().Set("Content-Type", "text/csv; charset=utf-8")
 	w.Header().Set("Content-Disposition", "attachment; filename=chat-log.csv")
 	fmt.Fprintln(w, "id,room,username,type,text,timestamp")
 	for _, msg := range messages {
 		text := strings.ReplaceAll(msg.Text, `"`, `""`)
 		fmt.Fprintf(w, "%d,%s,%s,%s,\"%s\",%s\n",
 			msg.ID, msg.Room, msg.Username, msg.Type, text, msg.Timestamp.Format(time.RFC3339))
 	}
 }
 // handleAdminChatLogBulk deletes multiple chat log entries by ID
 func handleAdminChatLogBulk(w http.ResponseWriter, r *http.Request) {
 	if r.Method != http.MethodDelete {
@@ -2109,6 +2582,19 @@ func handleAdminChatLogBulk(w http.ResponseWriter, r *http.Request) {
 }
 func main() {
 	// Load env-configurable rate limits
 	if raw := strings.TrimSpace(os.Getenv("CHAT_RATE_LIMIT_MAX")); raw != "" {
 		if v, err := strconv.Atoi(raw); err == nil && v > 0 {
 			rateLimitMax = v
 		}
 	}
 	if raw := strings.TrimSpace(os.Getenv("CHAT_RATE_LIMIT_WINDOW_S")); raw != "" {
 		if v, err := strconv.Atoi(raw); err == nil && v > 0 {
 			rateLimitWindow = time.Duration(v) * time.Second
 		}
 	}
 	log.Printf("Rate limit: %d messages per %v", rateLimitMax, rateLimitWindow)
 	initRedis()
 	initDB()
@@ -2122,13 +2608,18 @@ func main() {
 	http.HandleFunc("/api/admin/moderation/actions", requireAdminAuth(handleAdminModerationAction))
 	http.HandleFunc("/api/admin/analytics", requireAdminAuth(handleAdminAnalytics))
 	http.HandleFunc("/api/admin/system", requireAdminAuth(handleAdminSystemSummary))
 	http.HandleFunc("/api/admin/config", requireAdminAuth(handleAdminConfig))
 	http.HandleFunc("/api/admin/restart", requireAdminAuth(handleAdminRestart))
 	http.HandleFunc("/api/admin/users", requireAdminAuth(handleAdminUsers))
 	http.HandleFunc("/api/admin/schedule", requireAdminAuth(handleAdminSchedule))
 	http.HandleFunc("/api/admin/schedule/overrides", requireAdminAuth(handleAdminScheduleOverrides))
 	http.HandleFunc("/api/schedule", handlePublicSchedule)
 	http.HandleFunc("/api/admin/media", requireAdminAuth(handleAdminMedia))
 	http.HandleFunc("/api/admin/media/uploads", requireAdminAuth(handleAdminMediaUploads))
 	http.HandleFunc("/api/admin/media/uploads/", requireAdminAuth(handleAdminMediaUploads))
 	http.HandleFunc("/api/admin/media/", requireAdminAuth(handleAdminMediaByID))
 	http.HandleFunc("/api/admin/chat-log/bulk", requireAdminAuth(handleAdminChatLogBulk))
 	http.HandleFunc("/api/admin/chat-log/export", requireAdminAuth(handleAdminChatLogExport))
 	http.HandleFunc("/api/admin/chat-log/", requireAdminAuth(handleAdminChatLogByID))
 	http.HandleFunc("/api/admin/chat-log", requireAdminAuth(handleAdminChatLog))
 	http.HandleFunc("/metrics", handleMetrics)
@@ -18,8 +18,8 @@ RUN apk add --no-cache \
    bash
 # Set working directory for playout
 WORKDIR /app
-# Create directories for playlist, media, and HLS output
+# Create directories for playlist, media, HLS output, and emergency slate
-RUN mkdir -p /app/hls /app/media /app/playlists
+RUN mkdir -p /app/hls /app/media /app/playlists /app/slate
 # Copy the playout start script and the built playlist manager binary
 COPY start-playout.sh /app/
 # Copy demo data for out-of-the-box playout
@@ -3,11 +3,13 @@ package main
 import (
 	"bufio"
 	"context"
 	"encoding/json"
 	"fmt"
 	"net/http"
 	"os"
 	"os/exec"
 	"path/filepath"
 	"strconv"
 	"strings"
 	"time"
@@ -25,8 +27,18 @@ type VideoFile struct {
 }
 var (
-	r2Client *s3.Client
+	r2Client      *s3.Client
-	bucket   = os.Getenv("R2_BUCKET_NAME")
+	bucket        = os.Getenv("R2_BUCKET_NAME")
 	playoutMode   = "starting" // "live", "slate", "degraded"
 	restartCount  = 0
 	restartWindow = time.Now()
 	slateDir      = "/app/slate"
 	hlsDir        = "/app/hls"
 )
 const (
 	maxRestartsPerMinute = 5
 	slateManifestName    = "playlist.m3u8"
 )
 // initR2Client initializes the R2 (S3-compatible) client
@@ -79,23 +91,181 @@ func LoadPlaylist(playlistPath string) ([]VideoFile, error) {
 // ValidateVideo uses ffprobe to enforce codec, fps, and keyframe interval (ADR-001)
 func ValidateVideo(videoPath string) (VideoFile, error) {
 	v := VideoFile{Path: videoPath}
 	var errors []string
 	// Run ffprobe
 	cmd := exec.Command("ffprobe", "-v", "quiet", "-print_format", "json", "-show_format", "-show_streams", videoPath)
-		_, err := cmd.Output()
+	output, err := cmd.Output()
 	if err != nil {
 		v.Validation = "ffprobe failed: " + err.Error()
-		return v, err
+		return v, fmt.Errorf("ffprobe: %w", err)
 	}
-	// TODO: Parse JSON for strict checks (codec_name=h264, r_frame_rate=30/1, key_frame interval)
+	// Parse JSON
-	// For MVP we assume valid if ffprobe succeeds
+	var probe struct {
-	v.Valid = true
+		Streams []struct {
-	v.Validation = "Validation passed (H.264/AVC, AAC, 30fps constant, 2s keyframes - full JSON parse TODO per ADR-001)"
+			CodecName  string `json:"codec_name"`
-	v.Duration = 60.0 // placeholder from ffprobe
+			CodecType  string `json:"codec_type"`
 			Width      int    `json:"width"`
 			Height     int    `json:"height"`
 			RFrameRate string `json:"r_frame_rate"`
 			PixFmt     string `json:"pix_fmt"`
 			SampleRate string `json:"sample_rate"`
 			Channels   int    `json:"channels"`
 			Duration   string `json:"duration"`
 		} `json:"streams"`
 		Format struct {
 			Duration string `json:"duration"`
 		} `json:"format"`
 	}
 	if err := json.Unmarshal(output, &probe); err != nil {
 		v.Validation = "ffprobe JSON parse failed: " + err.Error()
 		return v, fmt.Errorf("ffprobe json: %w", err)
 	}
 	if len(probe.Streams) == 0 {
 		errors = append(errors, "no streams detected")
 	}
 	var hasVideo, hasAudio bool
 	for _, s := range probe.Streams {
 		switch s.CodecType {
 		case "video":
 			hasVideo = true
 			if s.CodecName != "h264" {
 				errors = append(errors, fmt.Sprintf("video codec must be h264, got %s", s.CodecName))
 			}
 			if s.RFrameRate != "30/1" {
 				errors = append(errors, fmt.Sprintf("framerate must be 30/1, got %s", s.RFrameRate))
 			}
 			if s.Width != 1280 && s.Width != 1920 {
 				errors = append(errors, fmt.Sprintf("width must be 1280 or 1920, got %d", s.Width))
 			}
 			if s.Height != 720 && s.Height != 1080 {
 				errors = append(errors, fmt.Sprintf("height must be 720 or 1080, got %d", s.Height))
 			}
 			if s.PixFmt != "yuv420p" {
 				errors = append(errors, fmt.Sprintf("pixel format must be yuv420p, got %s", s.PixFmt))
 			}
 		case "audio":
 			hasAudio = true
 			if s.CodecName != "aac" {
 				errors = append(errors, fmt.Sprintf("audio codec must be aac, got %s", s.CodecName))
 			}
 			if s.SampleRate != "48000" {
 				errors = append(errors, fmt.Sprintf("audio sample rate must be 48000, got %s", s.SampleRate))
 			}
 		}
 	}
 	if !hasVideo {
 		errors = append(errors, "no video stream found")
 	}
 	if !hasAudio {
 		errors = append(errors, "no audio stream found")
 	}
 	// Parse duration from format or stream
 	durationSec := 0.0
 	if probe.Format.Duration != "" {
 		if d, err := strconv.ParseFloat(probe.Format.Duration, 64); err == nil {
 			durationSec = d
 		}
 	}
 	if len(errors) > 0 {
 		v.Valid = false
 		v.Validation = strings.Join(errors, "; ")
 		return v, fmt.Errorf("validation failed: %s", v.Validation)
 	}
 	// Validate keyframe interval <=2s (60 frames at 30fps)
 	keyframeErr := validateKeyframeInterval(videoPath)
 	if keyframeErr != nil {
 		errors = append(errors, keyframeErr.Error())
 	}
 	if len(errors) > 0 {
 		v.Valid = false
 		v.Validation = strings.Join(errors, "; ")
 		return v, fmt.Errorf("validation failed: %s", v.Validation)
 	}
 	v.Valid = true
 	v.Duration = durationSec
 	v.Validation = fmt.Sprintf("OK: H.264/AAC, 30fps, yuv420p, 48kHz, %.1fs, keyframes OK", durationSec)
 	return v, nil
 }
 // validateKeyframeInterval checks that max gap between keyframes <=2s (60 frames at 30fps).
 func validateKeyframeInterval(videoPath string) error {
 	cmd := exec.Command("ffprobe",
 		"-v", "quiet",
 		"-select_streams", "v:0",
 		"-show_frames",
 		"-show_entries", "frame=key_frame,pkt_pts_time",
 		"-of", "csv=p=0",
 		videoPath)
 	output, err := cmd.Output()
 	if err != nil {
 		return fmt.Errorf("keyframe probe failed: %w", err)
 	}
 	type kfEntry struct{ pts float64 }
 	var keyframes []kfEntry
 	lines := strings.Split(strings.TrimSpace(string(output)), "\n")
 	for _, line := range lines {
 		line = strings.TrimSpace(line)
 		if line == "" {
 			continue
 		}
 		parts := strings.Split(line, ",")
 		if len(parts) < 2 || parts[0] != "1" {
 			continue
 		}
 		pts, err := strconv.ParseFloat(strings.TrimSpace(parts[1]), 64)
 		if err != nil {
 			continue
 		}
 		keyframes = append(keyframes, kfEntry{pts})
 	}
 	if len(keyframes) < 2 {
 		return fmt.Errorf("insufficient keyframes for interval analysis (need >=2, got %d)", len(keyframes))
 	}
 	maxGap := 0.0
 	for i := 1; i < len(keyframes); i++ {
 		gap := keyframes[i].pts - keyframes[i-1].pts
 		if gap > maxGap {
 			maxGap = gap
 		}
 	}
 	if maxGap > 2.1 { // small tolerance for floating point
 		return fmt.Errorf("keyframe interval too large: max %.2fs (must be <=2s)", maxGap)
 	}
 	return nil
 }
 // ValidateVideoStrict runs ValidateVideo and returns a structured JSON result.
 func ValidateVideoStrict(videoPath string) map[string]any {
 	v, err := ValidateVideo(videoPath)
 	result := map[string]any{
 		"path":   videoPath,
 		"valid":  v.Valid,
 		"errors": []string{},
 	}
 	if err != nil {
 		result["errors"] = strings.Split(v.Validation, "; ")
 	}
 	if v.Valid {
 		result["duration_seconds"] = v.Duration
 	}
 	return result
 }
 // ValidatePlaylist runs normalization validation on all entries
 func ValidatePlaylist(playlistPath string) ([]VideoFile, error) {
 	videos, err := LoadPlaylist(playlistPath)
@@ -139,8 +309,65 @@ func SyncToR2(localPath, r2Key string) error {
 // HealthHandler provides a simple health check endpoint
 func HealthHandler(w http.ResponseWriter, r *http.Request) {
 	w.Header().Set("Content-Type", "application/json")
 	status := "healthy"
 	if playoutMode == "slate" {
 		status = "degraded"
 	}
 	w.WriteHeader(http.StatusOK)
-	fmt.Fprint(w, `{"status":"healthy","service":"playout","timestamp":"`+time.Now().UTC().Format(time.RFC3339)+`"}`)
+	fmt.Fprintf(w, `{"status":"%s","service":"playout","mode":"%s","restarts":%d,"timestamp":"%s"}`,
 		status, playoutMode, restartCount, time.Now().UTC().Format(time.RFC3339))
 }
 // activateSlate copies pre-rendered slate HLS into the live output directory.
 // Writes a static manifest referencing slate segments. Returns error if slate not found.
 func activateSlate() error {
 	slateHLS := filepath.Join(slateDir, "hls")
 	if _, err := os.Stat(filepath.Join(slateHLS, "slate.m3u8")); os.IsNotExist(err) {
 		return fmt.Errorf("slate HLS not found at %s — run scripts/generate-slate.sh first", slateHLS)
 	}
 	// Clear existing live segments
 	if err := resetHLSOutput(hlsDir); err != nil {
 		return fmt.Errorf("failed to clear HLS output for slate: %w", err)
 	}
 	// Copy slate segments into live HLS dir
 	slateFiles, err := filepath.Glob(filepath.Join(slateHLS, "*"))
 	if err != nil {
 		return err
 	}
 	for _, src := range slateFiles {
 		dst := filepath.Join(hlsDir, filepath.Base(src))
 		data, err := os.ReadFile(src)
 		if err != nil {
 			return err
 		}
 		if err := os.WriteFile(dst, data, 0o644); err != nil {
 			return err
 		}
 	}
 	playoutMode = "slate"
 	fmt.Printf("[%s] EMERGENCY: Switched to slate fallback. %d restarts in window.\n",
 		time.Now().Format(time.RFC3339), restartCount)
 	return nil
 }
 // deactivateSlate clears slate state and prepares for live playout resumption.
 func deactivateSlate() {
 	playoutMode = "live"
 	fmt.Printf("[%s] RECOVERY: Slate deactivated, resuming live playout.\n",
 		time.Now().Format(time.RFC3339))
 }
 // shouldEscalateToSlate checks if restart count exceeds threshold within the window.
 func shouldEscalateToSlate() bool {
 	if time.Since(restartWindow) > 60*time.Second {
 		restartCount = 0
 		restartWindow = time.Now()
 		return false
 	}
 	return restartCount >= maxRestartsPerMinute
 }
 func resetHLSOutput(hlsDir string) error {
@@ -207,6 +434,21 @@ func main() {
 	// Start HTTP health check server
 	http.HandleFunc("/health", HealthHandler)
 	http.HandleFunc("/metrics", func(w http.ResponseWriter, r *http.Request) {
 		w.Header().Set("Content-Type", "text/plain; version=0.0.4; charset=utf-8")
 		fmt.Fprintln(w, "# HELP linearvoid_playout_restarts_total Total FFmpeg restarts.")
 		fmt.Fprintln(w, "# TYPE linearvoid_playout_restarts_total counter")
 		fmt.Fprintf(w, "linearvoid_playout_restarts_total %d\n", restartCount)
 		fmt.Fprintln(w, "# HELP linearvoid_playout_mode Current playout mode (0=live, 1=slate, 2=degraded).")
 		fmt.Fprintln(w, "# TYPE linearvoid_playout_mode gauge")
 		modeVal := 0
 		if playoutMode == "slate" {
 			modeVal = 1
 		} else if playoutMode == "degraded" {
 			modeVal = 2
 		}
 		fmt.Fprintf(w, "linearvoid_playout_mode %d\n", modeVal)
 	})
 	go func() {
 		fmt.Println("Health check server listening on :8081/health")
 		if err := http.ListenAndServe(":8081", nil); err != nil {
@@ -214,9 +456,14 @@ func main() {
 		}
 	}()
-	// Run FFmpeg in a loop for continuous playback with R2 sync hook
+	// Run FFmpeg in a loop for continuous playback with slate fallback
 	for {
-		if err := resetHLSOutput("/app/hls"); err != nil {
+		if playoutMode == "slate" {
 			// During slate: attempt recovery by restarting FFmpeg
 			fmt.Printf("[%s] Slate active — attempting live playout recovery...\n", time.Now().Format(time.RFC3339))
 		}
 		if err := resetHLSOutput(hlsDir); err != nil {
 			fmt.Println("Failed to reset HLS output:", err)
 			time.Sleep(5 * time.Second)
 			continue
@@ -241,12 +488,32 @@ func main() {
 			"-hls_segment_filename", "/app/hls/segment_%Y%m%d_%H%M%S.m4s",
 			"/app/hls/playlist.m3u8")
-		if err := cmd.Run(); err != nil {
+		runErr := cmd.Run()
-			fmt.Println("FFmpeg exited with error. Restarting in 5s (per ADR-001 resilience)...")
+
 		// Track restart and check for slate escalation
 		restartCount++
 		fmt.Printf("[%s] FFmpeg exited (restart #%d in window): %v\n",
 			time.Now().Format(time.RFC3339), restartCount, runErr)
 		if shouldEscalateToSlate() {
 			fmt.Printf("[%s] CRITICAL: %d restarts in 60s — escalating to slate fallback\n",
 				time.Now().Format(time.RFC3339), restartCount)
 			if err := activateSlate(); err != nil {
 				fmt.Printf("[%s] Slate activation failed: %v — will retry\n",
 					time.Now().Format(time.RFC3339), err)
 			}
 			// Stay in slate mode, retry recovery after delay
 			time.Sleep(30 * time.Second)
 			continue
 		}
 		// If we were in slate but FFmpeg ran successfully, we recovered
 		if playoutMode == "slate" {
 			deactivateSlate()
 		}
 		// After FFmpeg run, sync latest segments and manifest to R2
-		if err := syncLatestToR2("/app/hls"); err != nil {
+		if err := syncLatestToR2(hlsDir); err != nil {
 			fmt.Println("R2 sync warning:", err)
 		}
@@ -1,3 +1,9 @@
 # docker-compose.prod.yml — TEST LAB DEPLOYMENT
 # Target: test lab host 192.168.88.40 (NOT Hetzner production).
 # Production Hetzner VPS not yet provisioned — see TODO.md Production Deployment section.
 # Uses pre-built images from Gitea Container Registry (no local build).
 # Override DOCKER_HOST in CD workflow to switch target.
 services:
  playout:
    image: git.allucanget.biz/zwitschi/linearvoid/playout:latest
@@ -9,6 +15,7 @@ services:
      - ./data/playlist:/app/playlist:rw
      - ./data/media:/app/media:ro
      - ./data/hls:/app/hls:rw
      - ./data/slate:/app/slate:ro
    networks:
      - linearvoid-net
    depends_on:
@@ -68,7 +75,7 @@ services:
    image: redis:7-alpine
    container_name: linearvoid-redis
    restart: unless-stopped
-    command: redis-server --appendonly yes
+    command: redis-server --appendonly yes --maxmemory 256mb --maxmemory-policy allkeys-lru
    volumes:
      - redis-data:/data
    networks:
@@ -1,3 +1,8 @@
 # docker-compose.yml — LOCAL DEVELOPMENT
 # Target: local workstation or test lab (192.168.88.0/24).
 # NOT for production. Use docker-compose.prod.yml for deployment.
 # Services build from source; ports exposed for direct dev access.
 services:
  playout:
    image: ${CI_REGISTRY_URL:-git.allucanget.biz}/${CI_REGISTRY_NAMESPACE:-zwitschi/linearvoid}/playout:latest
@@ -12,6 +17,7 @@ services:
      - ./data/playlist:/app/playlist:ro
      - ./data/media:/app/media:ro
      - ./data/hls:/app/hls:rw
      - ./data/slate:/app/slate:ro
    networks:
      - linearvoid-net
    depends_on:
@@ -72,7 +78,7 @@ services:
    image: redis:7-alpine
    container_name: linearvoid-redis
    restart: unless-stopped
-    command: redis-server --appendonly yes
+    command: redis-server --appendonly yes --maxmemory 256mb --maxmemory-policy allkeys-lru
    volumes:
      - redis-data:/data
    networks:
@@ -284,7 +284,7 @@ Notable aspects: Manifest freshness ensures all viewers stay on same timeline; c
 ### CI/CD Pipeline Architecture
-The deployment follows a two-stage pipeline: **CI builds and pushes images**, then **CD pulls and deploys** them to the production host.
+The deployment follows a two-stage pipeline: **CI builds and pushes images**, then **CD pulls and deploys** them. Currently targeting the **test lab** (192.168.88.40). Production Hetzner VPS is planned but not yet provisioned — the same pipeline will deploy there by changing `DOCKER_HOST`.
 ```mermaid
 flowchart LR
@@ -295,7 +295,7 @@ flowchart LR
    subgraph "Gitea Container Registry"
        REGISTRY[git.allucanget.biz<br/>playout:latest<br/>chat:latest<br/>nginx:latest]
    end
-    subgraph "Production Host (192.168.88.40)"
+    subgraph "Test Lab Host (192.168.88.40) — Production Hetzner TBD"
        DOCKER[Docker Engine<br/>via TCP :2375]
        PLAYOUT[linearvoid-playout]
        CHAT[linearvoid-chat]
@@ -331,7 +331,7 @@ flowchart LR
   - Pulls latest images from registry
   - Generates `.env` from secrets
   - Seeds Prometheus config into named volume
-   - Deploys via `docker compose -f docker-compose.prod.yml up -d` to remote host (`192.168.88.40:2375`)
+   - Deploys via `docker compose -f docker-compose.prod.yml up -d` to remote host (`192.168.88.40:2375` — test lab; switch to Hetzner IP for production)
   - Runs health checks with retry logic for playout initialization
 ### Infrastructure Level 1
@@ -350,7 +350,7 @@ flowchart LR
 ### Infrastructure Level 2
-**Hetzner VPS**: Runs playout (FFmpeg/MediaMTX), chat backend, Nginx. Monitoring via dashboards + UptimeRobot. Backups to R2.
+**Hetzner VPS (planned):** Will run playout (FFmpeg/MediaMTX), chat backend, Nginx. Monitoring via dashboards + UptimeRobot. Backups to R2. Currently test lab (`192.168.88.40`) serves this role. Production Hetzner instance not yet provisioned — see `TODO.md` Production Deployment section.
 **Cloudflare Layer**:
@@ -24,6 +24,10 @@
    <section class="viewer-content" aria-label="Live stream and chat layout">
      <section class="player-stage" aria-label="Video stage">
        <video id="player" class="player" controls autoplay muted playsinline></video>
        <div id="now-playing" class="now-playing-overlay" aria-live="polite">
          <span id="np-title">Loading...</span>
          <span id="np-next" class="np-next"></span>
        </div>
      </section>
      <aside id="chat-panel" class="chat-sidebar" aria-label="Chat panel">
@@ -37,6 +41,10 @@
        <section id="messages" class="chat-messages" aria-live="polite" aria-label="Message stream"></section>
        <section id="presence-panel" class="presence-panel" aria-label="Online users">
          <div id="presence-list" class="presence-list"></div>
        </section>
        <div class="chat-input-area">
          <div class="chat-input-row">
            <label for="message-input" class="sr-only">Message input</label>
@@ -1,7 +1,7 @@
 {
  "name": "frontend",
  "private": true,
-  "version": "1.0.6",
+  "version": "1.0.7",
  "type": "module",
  "scripts": {
    "dev": "vite",
@@ -3,7 +3,15 @@
        <h1>Analytics</h1>
        <p>Basic activity counters from chat history and moderation audit logs.</p>
    </div>
-    <button id="reload-analytics-btn" type="button" class="btn btn-secondary">Reload analytics</button>
+    <div class="button-row">
        <select id="analytics-range" class="text-input" style="width:auto">
            <option value="1h">Last hour</option>
            <option value="6h">Last 6 hours</option>
            <option value="24h" selected>Last 24 hours</option>
            <option value="7d">Last 7 days</option>
        </select>
        <button id="reload-analytics-btn" type="button" class="btn btn-secondary">Reload analytics</button>
    </div>
 </div>
 <div class="stat-grid">
@@ -3,7 +3,10 @@
        <h1>Moderation</h1>
        <p>Create moderation actions and review the recent immutable audit log.</p>
    </div>
-    <button id="reload-moderation-btn" type="button" class="btn btn-secondary">Reload logs</button>
+    <div class="button-row">
        <button id="reload-moderation-btn" type="button" class="btn btn-secondary">Reload logs</button>
        <button id="export-chat-log-btn" type="button" class="btn btn-secondary">Export CSV</button>
    </div>
 </div>
 <div class="moderation-grid">
@@ -1,7 +1,7 @@
 <div class="panel-header-row">
    <div>
        <h1>Playlist</h1>
-        <p>Edit the active concat playlist used by the playout service.</p>
+        <p>Edit the active concat playlist. Drag entries to reorder.</p>
    </div>
    <div class="button-row">
        <button id="reload-playlist-btn" type="button" class="btn btn-secondary">Reload</button>
@@ -10,7 +10,9 @@
 </div>
 <div class="panel-card">
-    <label for="playlist-content" class="sr-only">Playlist content</label>
+    <div id="playlist-warnings" class="status-warnings" hidden></div>
-    <textarea id="playlist-content" class="text-input text-area" spellcheck="false"></textarea>
+    <ul id="playlist-sortable" class="sortable-list" aria-label="Playlist entries"></ul>
    <label for="playlist-content" class="sr-only">Playlist content (raw)</label>
    <textarea id="playlist-content" class="text-input text-area" spellcheck="false" rows="6"></textarea>
    <p id="playlist-status" class="status-line" aria-live="polite">Loading playlist...</p>
 </div>
@@ -23,4 +23,31 @@
        </table>
    </div>
    <p id="schedule-status" class="status-line" aria-live="polite">Loading schedule...</p>
 </div>
 <div class="panel-card">
    <h2>Schedule Overrides</h2>
    <p>Insert scheduled overrides to play specific videos at specific times.</p>
    <form id="override-form" class="form-stack" style="max-width:500px">
        <label>Media ID <input id="override-media-id" type="number" class="text-input" required /></label>
        <label>Start Time <input id="override-start" type="datetime-local" class="text-input" required /></label>
        <label>End Time <input id="override-end" type="datetime-local" class="text-input" required /></label>
        <label>Reason <input id="override-reason" type="text" class="text-input" placeholder="e.g. special event" /></label>
        <button type="submit" class="btn btn-primary">Add Override</button>
    </form>
    <p id="override-status" class="status-line" aria-live="polite"></p>
    <div class="table-wrap" style="margin-top:1rem">
        <table class="data-table">
            <thead>
                <tr>
                    <th>Media ID</th>
                    <th>Start</th>
                    <th>End</th>
                    <th>Reason</th>
                    <th></th>
                </tr>
            </thead>
            <tbody id="override-table-body"></tbody>
        </table>
    </div>
 </div>
@@ -52,3 +52,24 @@
    <div id="system-services" class="service-list"></div>
    <p id="system-status" class="status-line" aria-live="polite">Loading system summary...</p>
 </div>
 <div class="panel-card">
    <h2>Runtime Configuration</h2>
    <form id="config-form" class="form-stack" style="max-width:400px">
        <label>Rate Limit Max <input id="config-rate-max" type="number" class="text-input" /></label>
        <label>Rate Limit Window (seconds) <input id="config-rate-window" type="number" class="text-input" /></label>
        <button type="submit" class="btn btn-primary">Save Config</button>
    </form>
    <p id="config-status" class="status-line" aria-live="polite"></p>
 </div>
 <div class="panel-card">
    <h2>Service Control</h2>
    <p class="small-muted">Restart individual services (manual — container restart commands returned by API).</p>
    <div class="button-row">
        <button class="btn btn-secondary restart-btn" data-service="playout">Restart Playout</button>
        <button class="btn btn-secondary restart-btn" data-service="chat">Restart Chat</button>
        <button class="btn btn-secondary restart-btn" data-service="nginx">Restart Nginx</button>
    </div>
    <p id="restart-status" class="status-line" aria-live="polite"></p>
 </div>
@@ -14,6 +14,7 @@
                    <th>Username</th>
                    <th>Room</th>
                    <th>Online</th>
                    <th>Actions</th>
                </tr>
            </thead>
            <tbody id="users-table-body"></tbody>
@@ -259,10 +259,13 @@ async function refreshPlaylist() {
    if (!response.ok) throw new Error(`HTTP ${response.status}`);
    const payload = await response.json();
    const content: string = payload.content || "";
    const textarea = document.getElementById(
      "playlist-content",
    ) as HTMLTextAreaElement | null;
-    if (textarea) textarea.value = payload.content || "";
+    if (textarea) textarea.value = content;
    renderPlaylistSortable(content);
    await showPlaylistWarnings(content);
    setStatus("playlist-status", "Playlist loaded.");
  } catch (error) {
    console.error("Failed to load playlist", error);
@@ -270,6 +273,95 @@ async function refreshPlaylist() {
  }
 }
 function renderPlaylistSortable(content: string) {
  const list = document.getElementById("playlist-sortable");
  if (!list) return;
  const lines = content.split("\n").filter((l) => l.trim() && !l.startsWith("#"));
  list.innerHTML = lines
    .map((line, i) => {
      const path = line.replace(/^file\s+/, "").replace(/['"]/g, "").trim();
      return `<li class="sortable-item" draggable="true" data-index="${i}">
        <span class="drag-handle" aria-hidden="true">⋮⋮</span>
        <span class="sortable-index">${i + 1}</span>
        <span class="sortable-path">${path}</span>
        <button type="button" class="btn btn-secondary btn-sm" data-remove="${i}">✕</button>
      </li>`;
    })
    .join("");
  let dragSrc: number | null = null;
  list.querySelectorAll<HTMLElement>(".sortable-item").forEach((item) => {
    item.addEventListener("dragstart", () => {
      dragSrc = Number(item.dataset.index);
      item.classList.add("dragging");
    });
    item.addEventListener("dragend", () => {
      item.classList.remove("dragging");
      dragSrc = null;
    });
    item.addEventListener("dragover", (e) => e.preventDefault());
    item.addEventListener("drop", (e) => {
      e.preventDefault();
      const dst = Number(item.dataset.index);
      if (dragSrc !== null && dragSrc !== dst) reorderPlaylistEntry(dragSrc, dst);
    });
    item.querySelector("[data-remove]")?.addEventListener("click", () => {
      removePlaylistEntry(Number(item.dataset.index));
    });
  });
 }
 function getPlaylistLines(): string[] {
  const ta = document.getElementById("playlist-content") as HTMLTextAreaElement;
  return ta?.value.split("\n").filter((l) => l.trim() && !l.startsWith("#")) || [];
 }
 function syncPlaylistTextarea(lines: string[]) {
  const ta = document.getElementById("playlist-content") as HTMLTextAreaElement;
  if (ta) ta.value = lines.join("\n") + "\n";
  renderPlaylistSortable(lines.join("\n"));
 }
 function reorderPlaylistEntry(from: number, to: number) {
  const lines = getPlaylistLines();
  const [moved] = lines.splice(from, 1);
  lines.splice(to, 0, moved);
  syncPlaylistTextarea(lines);
 }
 function removePlaylistEntry(index: number) {
  const lines = getPlaylistLines();
  lines.splice(index, 1);
  syncPlaylistTextarea(lines);
 }
 async function showPlaylistWarnings(content: string) {
  const warnings = document.getElementById("playlist-warnings");
  if (!warnings) return;
  const lines = content.split("\n").filter((l) => l.trim() && !l.startsWith("#"));
  const msgs: string[] = [];
  if (lines.length === 0) msgs.push("Playlist is empty. Add files from the media library.");
  try {
    const resp = await fetch("/api/admin/media");
    if (resp.ok) {
      const media = await resp.json();
      const mediaPaths = new Set((media.files || []).map((f: { path: string }) => f.path));
      const nonNorm = (media.files || []).filter((f: { status: string }) => f.status === "needs_normalization");
      for (const line of lines) {
        const path = line.replace(/^file\s+/, "").replace(/['"]/g, "").trim();
        if (path && !mediaPaths.has(path)) msgs.push(`Missing from media library: ${path}`);
      }
      if (nonNorm.length > 0) msgs.push(`${nonNorm.length} file(s) need normalization. Run scripts/normalize.sh.`);
    }
  } catch { /* ignore */ }
  if (msgs.length > 0) {
    warnings.innerHTML = msgs.map((m) => `<div class="warning-msg">⚠ ${m}</div>`).join("");
    warnings.hidden = false;
  } else {
    warnings.hidden = true;
  }
 }
 async function savePlaylist() {
  if (state.playlistSaving) return;
  state.playlistSaving = true;
@@ -333,6 +425,55 @@ async function refreshSchedule() {
  }
 }
 async function refreshOverrides() {
  try {
    const resp = await fetch("/api/admin/schedule/overrides");
    if (!resp.ok) return;
    const overrides = await resp.json();
    const tbody = document.getElementById("override-table-body");
    if (!tbody) return;
    if (!overrides.length) {
      tbody.innerHTML = `<tr><td colspan="5">No overrides.</td></tr>`;
      return;
    }
    tbody.innerHTML = overrides
      .map(
        (o: { id: number; mediaId: number; startTime: string; endTime: string; reason: string }) =>
          `<tr><td>${o.mediaId}</td><td>${new Date(o.startTime).toLocaleString()}</td><td>${new Date(o.endTime).toLocaleString()}</td><td>${o.reason || "-"}</td><td><button class="btn btn-secondary btn-sm" data-delete-override="${o.id}">✕</button></td></tr>`,
      )
      .join("");
    tbody.querySelectorAll("[data-delete-override]").forEach((btn) => {
      btn.addEventListener("click", () => deleteOverride(Number((btn as HTMLElement).dataset.deleteOverride)));
    });
  } catch { /* non-critical */ }
 }
 async function submitOverride(e: Event) {
  e.preventDefault();
  const status = document.getElementById("override-status");
  if (status) status.textContent = "Saving...";
  const mediaId = (document.getElementById("override-media-id") as HTMLInputElement).value;
  const startTime = (document.getElementById("override-start") as HTMLInputElement).value;
  const endTime = (document.getElementById("override-end") as HTMLInputElement).value;
  const reason = (document.getElementById("override-reason") as HTMLInputElement).value;
  try {
    const resp = await fetch("/api/admin/schedule/overrides", {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({ mediaId: Number(mediaId), startTime: new Date(startTime).toISOString(), endTime: new Date(endTime).toISOString(), reason }),
    });
    if (!resp.ok) { const text = await resp.text(); throw new Error(text); }
    if (status) { status.textContent = "Override added."; status.className = "status-line"; }
    refreshOverrides();
  } catch (err) {
    if (status) { status.textContent = `Failed: ${err}`; status.className = "status-line status-error"; }
  }
 }
 async function deleteOverride(id: number) {
  try { await fetch(`/api/admin/schedule/overrides?id=${id}`, { method: "DELETE" }); refreshOverrides(); } catch { /* ignore */ }
 }
 async function refreshSystemSummary() {
  setStatus("system-status", "Loading system summary...");
  try {
@@ -756,9 +897,17 @@ function renderChatLogTable() {
      <td>${entry.type}</td>
      <td>${entry.timestamp}</td>
      <td class="action-cell">
-        <button type="button" class="btn btn-danger btn-small" data-action="delete-chat" data-id="${entry.id}">Delete</button>
+        <button type="button" class="btn btn-secondary btn-sm" data-action="chat-mute" data-user="${entry.username}">Mute</button>
        <button type="button" class="btn btn-secondary btn-sm" data-action="chat-ban" data-user="${entry.username}">Ban</button>
        <button type="button" class="btn btn-danger btn-sm" data-action="delete-chat" data-id="${entry.id}">Del</button>
      </td>
    `;
    tr.querySelector('[data-action="chat-mute"]')?.addEventListener("click", () => {
      userAction("mute", entry.username);
    });
    tr.querySelector('[data-action="chat-ban"]')?.addEventListener("click", () => {
      if (confirm(`Ban ${entry.username}?`)) userAction("ban", entry.username);
    });
    tr.querySelector('[data-action="delete-chat"]')?.addEventListener(
      "click",
      () => deleteChatEntry(entry.id),
@@ -930,9 +1079,19 @@ async function refreshUsers() {
    } else {
      users.forEach((user: any) => {
        const tr = document.createElement("tr");
-        tr.innerHTML = `<td>${user.username}</td><td>${user.room}</td><td>${user.online ? "yes" : "no"}</td>`;
+        tr.innerHTML = `<td>${user.username}</td><td>${user.room}</td><td>${user.online ? "yes" : "no"}</td>
          <td>
            <button class="btn btn-secondary btn-sm user-mute" data-user="${user.username}">Mute 10m</button>
            <button class="btn btn-secondary btn-sm user-ban" data-user="${user.username}">Ban</button>
            <button class="btn btn-secondary btn-sm user-unmute" data-user="${user.username}">Unmute</button>
            <button class="btn btn-secondary btn-sm user-unban" data-user="${user.username}">Unban</button>
          </td>`;
        tbody.appendChild(tr);
      });
      tbody.querySelectorAll(".user-mute").forEach(b => b.addEventListener("click", () => userAction("mute", (b as HTMLElement).dataset.user!)));
      tbody.querySelectorAll(".user-ban").forEach(b => b.addEventListener("click", () => userAction("ban", (b as HTMLElement).dataset.user!)));
      tbody.querySelectorAll(".user-unmute").forEach(b => b.addEventListener("click", () => userAction("unmute", (b as HTMLElement).dataset.user!)));
      tbody.querySelectorAll(".user-unban").forEach(b => b.addEventListener("click", () => userAction("unban", (b as HTMLElement).dataset.user!)));
    }
    setStatus(
@@ -947,6 +1106,63 @@ async function refreshUsers() {
  }
 }
 async function userAction(action: string, username: string) {
  try {
    const resp = await fetch("/api/admin/users", {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({ action, username, duration: 10 }),
    });
    if (!resp.ok) throw new Error(`HTTP ${resp.status}`);
    setStatus("users-status", `${action} ${username} OK.`);
  } catch (err) {
    setStatus("users-status", `Failed: ${err}`, true);
  }
 }
 async function loadConfig() {
  try {
    const resp = await fetch("/api/admin/config");
    if (!resp.ok) return;
    const cfg = await resp.json();
    (document.getElementById("config-rate-max") as HTMLInputElement).value = cfg.rateLimitMax;
    (document.getElementById("config-rate-window") as HTMLInputElement).value = cfg.rateLimitWindowSec;
  } catch { /* non-critical */ }
 }
 async function saveConfig(e: Event) {
  e.preventDefault();
  const status = document.getElementById("config-status");
  if (status) status.textContent = "Saving...";
  try {
    const resp = await fetch("/api/admin/config", {
      method: "PUT",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({
        rateLimitMax: Number((document.getElementById("config-rate-max") as HTMLInputElement).value),
        rateLimitWindowSec: Number((document.getElementById("config-rate-window") as HTMLInputElement).value),
      }),
    });
    if (!resp.ok) throw new Error(`HTTP ${resp.status}`);
    if (status) { status.textContent = "Config saved."; status.className = "status-line"; }
  } catch (err) {
    if (status) { status.textContent = `Failed: ${err}`; status.className = "status-line status-error"; }
  }
 }
 async function restartService(service: string) {
  if (!confirm(`Restart ${service}? This may cause brief interruption.`)) return;
  const status = document.getElementById("restart-status");
  if (status) status.textContent = `Requesting restart of ${service}...`;
  try {
    const resp = await fetch(`/api/admin/restart?service=${service}`, { method: "POST" });
    const data = await resp.json();
    if (status) status.textContent = data.message;
  } catch (err) {
    if (status) status.textContent = `Failed: ${err}`;
  }
 }
 function bindEvents() {
  document
    .querySelectorAll<HTMLButtonElement>(".tab-trigger")
@@ -1017,12 +1233,21 @@ function bindPageEvents(tabName: string) {
      document
        .getElementById("reload-schedule-btn")
        ?.addEventListener("click", refreshSchedule);
      document
        .getElementById("override-form")
        ?.addEventListener("submit", submitOverride);
      refreshOverrides();
      break;
    case "moderation":
      document
        .getElementById("reload-moderation-btn")
        ?.addEventListener("click", refreshModerationLogs);
      document
        .getElementById("export-chat-log-btn")
        ?.addEventListener("click", () => {
          window.open("/api/admin/chat-log/export", "_blank");
        });
      document
        .getElementById("moderation-form")
        ?.addEventListener("submit", submitModerationAction);
@@ -1083,6 +1308,13 @@ function bindPageEvents(tabName: string) {
      document
        .getElementById("reload-system-btn")
        ?.addEventListener("click", refreshSystemSummary);
      document
        .getElementById("config-form")
        ?.addEventListener("submit", saveConfig);
      document.querySelectorAll(".restart-btn").forEach((btn) =>
        btn.addEventListener("click", () => restartService((btn as HTMLElement).dataset.service!))
      );
      loadConfig();
      break;
  }
 }
@@ -16,6 +16,7 @@ let ws: WebSocket | null = null;
 let currentRoom = "main";
 let username = "viewer" + Math.floor(Math.random() * 1000);
 let chatVisible = true;
 const onlineUsers = new Set<string>();
 function resolveWebSocketBaseUrl() {
  const configuredUrl = import.meta.env.VITE_PUBLIC_WS_URL?.trim();
@@ -74,6 +75,19 @@ function connectWebSocket(room: string) {
  ws.onmessage = (event) => {
    const msg = JSON.parse(event.data);
    addMessage(msg.type || "public", msg.text, msg.username, msg.timestamp);
    // Track presence from system join/leave messages
    if (msg.type === "system" && msg.username === "system") {
      const joined = msg.text?.match(/^(\S+) joined /);
      const left = msg.text?.match(/^(\S+) left /);
      if (joined) {
        onlineUsers.add(joined[1]);
        renderPresence();
      } else if (left) {
        onlineUsers.delete(left[1]);
        renderPresence();
      }
    }
  };
  ws.onclose = () => {
@@ -112,6 +126,37 @@ function addMessage(
  messages.scrollTop = messages.scrollHeight;
 }
 function renderPresence() {
  const list = document.getElementById("presence-list");
  if (!list) return;
  const sorted = [...onlineUsers].sort();
  list.innerHTML = sorted
    .map(
      (u) =>
        `<span class="presence-dot" title="${u}"><span class="presence-indicator"></span>${u}</span>`,
    )
    .join("");
 }
 async function refreshSchedule() {
  try {
    const res = await fetch("/api/schedule");
    if (!res.ok) return;
    const data = await res.json();
    const entries = data.entries as Array<{ title: string; status: string }>;
    if (entries.length > 0) {
      const np = document.getElementById("np-title");
      const nn = document.getElementById("np-next");
      if (np) np.textContent = `Now: ${entries[0].title}`;
      if (nn && entries.length > 1) {
        nn.textContent = `Up next: ${entries[1].title}`;
      }
    }
  } catch {
    // Schedule unavailable — non-critical
  }
 }
 async function initPlayerAndChat() {
  const video = document.getElementById("player") as HTMLVideoElement;
  const manifestUrl = resolveManifestUrl();
@@ -136,6 +181,10 @@ async function initPlayerAndChat() {
  connectWebSocket("main");
  // Start schedule polling
  refreshSchedule();
  setInterval(refreshSchedule, 30000);
  console.log(
    "Linear Void Frontend initialized - HLS Player + Chat Sidebar ready",
  );
@@ -191,6 +191,74 @@ select {
  color: var(--danger);
 }
 .sortable-list {
  list-style: none;
  margin: 0 0 0.75rem;
  padding: 0;
  max-height: 300px;
  overflow-y: auto;
  border: 1px solid var(--line-soft);
  border-radius: 4px;
 }
 .sortable-item {
  display: flex;
  align-items: center;
  gap: 0.5rem;
  padding: 0.4rem 0.6rem;
  border-bottom: 1px solid var(--line-soft);
  cursor: grab;
  transition: background 0.15s;
 }
 .sortable-item:last-child {
  border-bottom: none;
 }
 .sortable-item:hover {
  background: var(--panel-2);
 }
 .sortable-item.dragging {
  opacity: 0.4;
 }
 .drag-handle {
  color: var(--ink-soft);
  font-size: 0.8rem;
  letter-spacing: 1px;
  cursor: grab;
  user-select: none;
 }
 .sortable-index {
  font-size: 0.7rem;
  color: var(--ink-soft);
  min-width: 1.5rem;
  text-align: right;
 }
 .sortable-path {
  flex: 1;
  font-size: 0.8rem;
  color: var(--ink-0);
  overflow: hidden;
  text-overflow: ellipsis;
  white-space: nowrap;
 }
 .status-warnings {
  background: rgba(212, 150, 36, 0.1);
  border: 1px solid var(--warn);
  padding: 0.5rem 0.75rem;
  margin-bottom: 0.75rem;
  border-radius: 4px;
 }
 .warning-msg {
  font-size: 0.8rem;
  color: var(--warn);
  line-height: 1.5;
 }
 .btn {
  border: 1px solid transparent;
  border-radius: var(--radius-1);
@@ -454,6 +522,21 @@ select {
  object-fit: contain;
 }
 .now-playing-overlay {
  padding: 0.5rem 0.75rem;
  background: var(--panel);
  border: 1px solid var(--line-soft);
  display: flex;
  justify-content: space-between;
  align-items: center;
  font-size: 0.8rem;
  color: var(--ink-0);
 }
 .np-next {
  color: var(--ink-soft);
 }
 .now-playing-overlay {
  position: absolute;
  right: calc(var(--space-5) + 0.7rem);
@@ -524,6 +607,35 @@ select {
  gap: var(--space-2);
 }
 .presence-panel {
  padding: 0.5rem 1rem;
  border-top: 1px solid var(--line-soft);
  max-height: 120px;
  overflow-y: auto;
 }
 .presence-list {
  display: flex;
  flex-wrap: wrap;
  gap: 0.4rem;
 }
 .presence-dot {
  display: inline-flex;
  align-items: center;
  gap: 0.3rem;
  font-size: 0.75rem;
  color: var(--ink-1);
 }
 .presence-indicator {
  width: 6px;
  height: 6px;
  border-radius: 50%;
  background: var(--ok);
  flex-shrink: 0;
 }
 .message-row {
  display: flex;
 }
@@ -160,18 +160,36 @@ http {
        }
        location = /hls/playlist.m3u8 {
            if ($request_method = OPTIONS) {
                add_header Access-Control-Allow-Origin "*";
                add_header Access-Control-Allow-Methods "GET, OPTIONS";
                add_header Access-Control-Max-Age 86400;
                return 204;
            }
            alias /srv/hls/playlist.m3u8;
            add_header Cache-Control "no-store, no-cache, must-revalidate, max-age=0";
            add_header Access-Control-Allow-Origin "*";
        }
        location = /hls/init.mp4 {
            if ($request_method = OPTIONS) {
                add_header Access-Control-Allow-Origin "*";
                add_header Access-Control-Allow-Methods "GET, OPTIONS";
                add_header Access-Control-Max-Age 86400;
                return 204;
            }
            alias /srv/hls/init.mp4;
            add_header Cache-Control "public, max-age=31536000, immutable";
            add_header Access-Control-Allow-Origin "*";
        }
        location ~* ^/hls/(.+\.(ts|m4s))$ {
            if ($request_method = OPTIONS) {
                add_header Access-Control-Allow-Origin "*";
                add_header Access-Control-Allow-Methods "GET, OPTIONS";
                add_header Access-Control-Max-Age 86400;
                return 204;
            }
            alias /srv/hls/$1;
            add_header Cache-Control "public, max-age=31536000, immutable";
            add_header Access-Control-Allow-Origin "*";
@@ -179,15 +197,29 @@ http {
        # Local/dev fallback HLS origin. Production media should use MEDIA_DOMAIN.
        location /hls/ {
            if ($request_method = OPTIONS) {
                add_header Access-Control-Allow-Origin "*";
                add_header Access-Control-Allow-Methods "GET, OPTIONS";
                add_header Access-Control-Max-Age 86400;
                return 204;
            }
            alias /srv/hls/;
            add_header Cache-Control "public, max-age=60";
            add_header Access-Control-Allow-Origin "*";
        }
-        # Health checks
+        # Health checks — aggregated from upstream services
        location /health {
-            return 200 "healthy";
+            default_type application/json;
-            add_header Content-Type text/plain;
+            return 200 '{"status":"ok","service":"nginx","timestamp":"$time_iso8601"}';
        }
        location /nginx-status {
            stub_status on;
            allow 127.0.0.1;
            allow 172.16.0.0/12;
            allow 192.168.0.0/16;
            deny all;
        }
    }
 }
@@ -0,0 +1,57 @@
 #!/bin/bash
 # Generate emergency slate video + pre-rendered HLS segments for failover.
 # Output: data/slate/ (slate MP4 + HLS segments + manifest)
 # Requires: ffmpeg
 set -e
 SLATE_DIR="${1:-data/slate}"
 mkdir -p "$SLATE_DIR"
 SLATE_MP4="$SLATE_DIR/slate.mp4"
 SLATE_HLS="$SLATE_DIR/hls"
 mkdir -p "$SLATE_HLS"
 echo "=== Generating Emergency Slate ==="
 # 1. Generate 10s slate video: color bars + "We'll Be Right Back" text
 echo "[1/3] Generating slate video (10s, H.264/AAC, 30fps, 2s keyframes)..."
 ffmpeg -y -f lavfi -i "color=c=#1a1a2e:s=1280x720:d=10:r=30" \
       -f lavfi -i "sine=frequency=440:duration=10" \
       -filter_complex "[0]drawtext=text='Linear Void':fontcolor=#587792:fontsize=60:x=(w-text_w)/2:y=(h-text_h)/2-40,drawtext=text='We'\''ll Be Right Back':fontcolor=#ede8e6:fontsize=36:x=(w-text_w)/2:y=(h-text_h)/2+30[bg];[1]volume=0.15[a]" \
       -map "[bg]" -map "[a]" \
       -c:v libx264 -preset medium -crf 21 \
       -r 30 -g 60 -keyint_min 60 -sc_threshold 0 \
       -pix_fmt yuv420p \
       -c:a aac -b:a 128k -ar 48000 -ac 2 \
       -movflags +faststart \
       -t 10 \
       "$SLATE_MP4"
 echo "   Slate MP4: $(du -h "$SLATE_MP4" | cut -f1)"
 # 2. Verify slate meets normalization profile
 echo "[2/3] Verifying slate normalization..."
 ffprobe -v error -show_entries stream=codec_name,width,height,r_frame_rate,pix_fmt,sample_rate \
        -of default=noprint_wrappers=1 "$SLATE_MP4" 2>&1 | head -10
 # 3. Package as pre-rendered HLS (fMP4, 6s segments)
 echo "[3/3] Packaging as HLS..."
 ffmpeg -y -i "$SLATE_MP4" \
       -c copy \
       -f hls \
       -hls_time 6 \
       -hls_list_size 5 \
       -hls_segment_type fmp4 \
       -hls_fmp4_init_filename "init.mp4" \
       -hls_flags "independent_segments" \
       -hls_segment_filename "$SLATE_HLS/slate_segment_%03d.m4s" \
       "$SLATE_HLS/slate.m3u8"
 echo ""
 echo "=== Slate Generated ==="
 echo "  MP4:      $SLATE_MP4"
 echo "  Manifest: $SLATE_HLS/slate.m3u8"
 echo "  Segments: $(find "$SLATE_HLS" -name '*.m4s' | wc -l) files"
 echo "  Init:     $SLATE_HLS/init.mp4"
 echo ""
 echo "To use: mount $SLATE_HLS as /app/slate in playout container"
@@ -0,0 +1,57 @@
 #!/bin/bash
 # Normalize video to Linear Void required profile.
 # Output: H.264/AAC, 30fps constant, 2s keyframes, yuv420p, 48kHz audio.
 # Usage: ./normalize.sh <input> [output]
 set -e
 INPUT="$1"
 if [ -z "$INPUT" ]; then
  echo "Usage: $0 <input-file> [output-file]"
  echo "  Normalizes video to Linear Void profile: H.264/AAC, 30fps, 2s keyframes"
  exit 1
 fi
 if [ ! -f "$INPUT" ]; then
  echo "Error: input file not found: $INPUT"
  exit 1
 fi
 OUTPUT="${2:-${INPUT%.*}-normalized.mp4}"
 CRF="${NORMALIZE_CRF:-21}"
 PRESET="${NORMALIZE_PRESET:-medium}"
 AUDIO_BITRATE="${NORMALIZE_AUDIO_BITRATE:-160k}"
 echo "=== Linear Void Video Normalization ==="
 echo "  Input:       $INPUT ($(du -h "$INPUT" | cut -f1))"
 echo "  Output:      $OUTPUT"
 echo "  CRF:         $CRF"
 echo "  Preset:      $PRESET"
 echo "  Audio rate:  $AUDIO_BITRATE"
 echo ""
 # Probe input
 echo "--- Input Properties ---"
 ffprobe -v error -show_entries stream=codec_name,width,height,r_frame_rate,pix_fmt,sample_rate,channels \
        -of default=noprint_wrappers=1 "$INPUT" 2>&1
 echo ""
 # Normalize
 echo "--- Normalizing ---"
 ffmpeg -y -i "$INPUT" \
  -c:v libx264 -preset "$PRESET" -crf "$CRF" \
  -r 30 -g 60 -keyint_min 60 -sc_threshold 0 \
  -pix_fmt yuv420p \
  -c:a aac -b:a "$AUDIO_BITRATE" -ar 48000 -ac 2 \
  -movflags +faststart \
  "$OUTPUT"
 echo ""
 echo "--- Output Properties ---"
 ffprobe -v error -show_entries stream=codec_name,width,height,r_frame_rate,pix_fmt,sample_rate,channels \
        -of default=noprint_wrappers=1 "$OUTPUT" 2>&1
 echo ""
 echo "=== Normalization Complete ==="
 echo "  Output: $OUTPUT ($(du -h "$OUTPUT" | cut -f1))"
 echo ""
 echo "Verify with: ffprobe -v error -show_entries stream=codec_name,r_frame_rate,pix_fmt -of default=noprint_wrappers=1 $OUTPUT"
@@ -0,0 +1,85 @@
 #!/bin/bash
 # End-to-end playout test: single file → 3-file playlist → verify seamless transition
 # Requires: Docker, ffprobe, curl. Run from repo root.
 set -e
 echo "=== Playout End-to-End Test ==="
 # 1. Build playout image
 echo "[1/7] Building playout image..."
 docker compose build playout
 # 2. Create test playlist with 3 demo files (reuse demodata if exists)
 TEST_PLAYLIST="data/playlist/playlist.txt"
 mkdir -p data/playlist data/hls
 echo "[2/7] Creating 3-file test playlist..."
 cat > "$TEST_PLAYLIST" << 'EOF'
 file '/app/media/demo1.mp4'
 file '/app/media/demo2.mp4'
 file '/app/media/demo1.mp4'
 EOF
 echo "Playlist created with 3 entries:"
 cat "$TEST_PLAYLIST"
 # 3. Validate playlist parses correctly
 echo "[3/7] Validating playlist parse..."
 LINE_COUNT=$(grep -c "^file " "$TEST_PLAYLIST" || true)
 if [ "$LINE_COUNT" -ne 3 ]; then
  echo "FAIL: Expected 3 entries, got $LINE_COUNT"
  exit 1
 fi
 echo "OK: $LINE_COUNT entries parsed"
 # 4. Start playout container
 echo "[4/7] Starting playout container..."
 docker compose up -d playout
 sleep 8
 # 5. Verify health endpoint
 echo "[5/7] Checking playout health..."
 HEALTH=$(curl -sf http://localhost:8081/health || echo "FAIL")
 if echo "$HEALTH" | grep -q "healthy"; then
  echo "OK: Health endpoint: $HEALTH"
 else
  echo "FAIL: Health check returned: $HEALTH"
  docker compose logs playout --tail 30
  exit 1
 fi
 # 6. Verify HLS output
 echo "[6/7] Verifying HLS output..."
 sleep 10  # Let FFmpeg produce some segments
 if [ -f "data/hls/playlist.m3u8" ]; then
  echo "OK: playlist.m3u8 exists"
  MANIFEST_LINES=$(wc -l < data/hls/playlist.m3u8)
  echo "   Manifest lines: $MANIFEST_LINES"
 else
  echo "FAIL: No playlist.m3u8 generated"
  docker compose logs playout --tail 30
  exit 1
 fi
 SEGMENT_COUNT=$(find data/hls -name "segment_*.m4s" | wc -l)
 if [ "$SEGMENT_COUNT" -ge 1 ]; then
  echo "OK: $SEGMENT_COUNT segment(s) generated"
 else
  echo "FAIL: No segments generated"
  exit 1
 fi
 # 7. Check for seamless transition markers (no FFmpeg errors in logs)
 echo "[7/7] Checking for seamless transitions..."
 ERRORS=$(docker compose logs playout 2>&1 | grep -ci "error" || true)
 if [ "$ERRORS" -eq 0 ]; then
  echo "OK: No FFmpeg errors in logs"
 else
  echo "WARN: $ERRORS error(s) in playout logs (may be R2 connection — check manually)"
 fi
 echo ""
 echo "=== Playout E2E Test PASSED ==="
 echo "Verified: playlist parse → HLS generation → health endpoint → segment output"
 echo ""
 echo "Cleanup: docker compose down playout"