diff --git a/apps/admin-ui/src/app/settings/page.tsx b/apps/admin-ui/src/app/settings/page.tsx
index 4d946ff..a1c7075 100644
--- a/apps/admin-ui/src/app/settings/page.tsx
+++ b/apps/admin-ui/src/app/settings/page.tsx
@@ -164,6 +164,10 @@ export default function SettingsPage() {
   const [tvLiveEventsUrl, setTvLiveEventsUrl] = useState(
     "http://epg.faabserver.nl/api/export/live-events?horizon_days=3"
   );
+  /** Providers die uit staan (denylist). Ontbrekende = aan. */
+  const [tvDisabledProviders, setTvDisabledProviders] = useState<string[]>([]);
+  /** Ontdekt uit feed + bekende disabled. */
+  const [tvLiveEventProviders, setTvLiveEventProviders] = useState<string[]>([]);
   const [tvShowAlle, setTvShowAlle] = useState(true);
   const [tvCategories, setTvCategories] = useState<
     Array<{ id: string; name: string; channelCount: number }>
@@ -262,8 +266,18 @@ export default function SettingsPage() {
               ? s.liveEventsUrl
               : "http://epg.faabserver.nl/api/export/live-events?horizon_days=3"
           );
+          setTvDisabledProviders(
+            Array.isArray(s.liveEventsDisabledProviders)
+              ? s.liveEventsDisabledProviders.map((p: string) => String(p).toLowerCase())
+              : []
+          );
         }
         setTvCategories(Array.isArray(d.categories) ? d.categories : []);
+        setTvLiveEventProviders(
+          Array.isArray(d.liveEventProviders)
+            ? d.liveEventProviders.map((p: string) => String(p).toLowerCase())
+            : []
+        );
       })
       .catch(() => undefined);
   }, []);
@@ -568,6 +582,7 @@ export default function SettingsPage() {
           categoryOrder: tvCategories.map((c) => c.id),
           showAlleZenders: tvShowAlle,
           liveEventsUrl: tvLiveEventsUrl.trim(),
+          liveEventsDisabledProviders: tvDisabledProviders,
         }),
       });
       const data = await res.json().catch(() => ({}));
@@ -586,8 +601,18 @@ export default function SettingsPage() {
             ? data.settings.liveEventsUrl
             : ""
         );
+        setTvDisabledProviders(
+          Array.isArray(data.settings.liveEventsDisabledProviders)
+            ? data.settings.liveEventsDisabledProviders.map((p: string) => String(p).toLowerCase())
+            : []
+        );
       }
       if (Array.isArray(data.categories)) setTvCategories(data.categories);
+      if (Array.isArray(data.liveEventProviders)) {
+        setTvLiveEventProviders(
+          data.liveEventProviders.map((p: string) => String(p).toLowerCase())
+        );
+      }
     } finally {
       setTvBusy(false);
     }
@@ -936,7 +961,7 @@ export default function SettingsPage() {
                 JSON-export (FAAB) voor de Events-tab in Android TV. Leeg laten schakelt de tab uit.
                 Default: FAAB live-events met 3 dagen horizon.
               </p>
-              <label style={{ display: "block" }}>
+              <label style={{ display: "block", marginBottom: "0.75rem" }}>
                 Feed-URL
                 <input
                   type="url"
@@ -947,6 +972,45 @@ export default function SettingsPage() {
                   autoComplete="off"
                 />
               </label>
+              <h4 style={{ fontSize: "0.95rem", margin: "0.5rem 0 0.35rem" }}>
+                Providers (cluster-breed)
+              </h4>
+              <p className="muted" style={{ marginBottom: "0.5rem" }}>
+                Vink aan welke providers zichtbaar zijn. Nieuwe providers die nog niet in de lijst
+                stonden blijven standaard aan, zodat de feed niet stilvalt.
+              </p>
+              {tvLiveEventProviders.length === 0 ? (
+                <p className="muted">
+                  Nog geen providers ontdekt — controleer de feed-URL en sla op / herlaad.
+                </p>
+              ) : (
+                <div className="check-rows">
+                  {tvLiveEventProviders.map((p) => {
+                    const enabled = !tvDisabledProviders.includes(p);
+                    return (
+                      <label
+                        key={p}
+                        className="check-row"
+                        style={{ display: "flex", gap: "0.6rem", alignItems: "center" }}
+                      >
+                        <input
+                          type="checkbox"
+                          checked={enabled}
+                          onChange={(e) => {
+                            setTvDisabledProviders((prev) => {
+                              if (e.target.checked) {
+                                return prev.filter((x) => x !== p);
+                              }
+                              return prev.includes(p) ? prev : [...prev, p];
+                            });
+                          }}
+                        />
+                        <span style={{ fontFamily: "monospace", fontSize: "0.9rem" }}>{p}</span>
+                      </label>
+                    );
+                  })}
+                </div>
+              )}
             </div>
 
             <div className="card">
diff --git a/apps/admin-ui/src/app/viewers/page.tsx b/apps/admin-ui/src/app/viewers/page.tsx
index fd7e26a..38064fa 100644
--- a/apps/admin-ui/src/app/viewers/page.tsx
+++ b/apps/admin-ui/src/app/viewers/page.tsx
@@ -56,6 +56,9 @@ type Viewer = {
   enabled: boolean;
   appAccess: boolean;
   iptvAccess: boolean;
+  liveEventsEnabled: boolean;
+  /** null = alle globaal-enabled providers */
+  liveEventsProviders: string[] | null;
   iptvAddonTokenId: string | null;
   liveListIds?: string[];
   liveLists?: Array<{ id: string; name: string; enabled: boolean }>;
@@ -179,6 +182,15 @@ export default function ViewersPage() {
   const [editEmails, setEditEmails] = useState<Record<string, string>>({});
   const [allLiveLists, setAllLiveLists] = useState<LiveListOption[]>([]);
   const [liveListDrafts, setLiveListDrafts] = useState<Record<string, string[]>>({});
+  /** Globaal beschikbare providers (minus disabled) voor per-user multi-select. */
+  const [globalEventProviders, setGlobalEventProviders] = useState<string[]>([]);
+  /**
+   * Draft per viewer: null = alle providers; string[] = subset.
+   * undefined in map = nog niet geïnitialiseerd → val terug op viewer.liveEventsProviders.
+   */
+  const [eventProviderDrafts, setEventProviderDrafts] = useState<
+    Record<string, string[] | null>
+  >({});
 
   const load = useCallback(() => {
     fetch("/api/v1/admin/viewers", { credentials: "include" })
@@ -200,6 +212,15 @@ export default function ViewersPage() {
           }
           return next;
         });
+        setEventProviderDrafts((prev) => {
+          const next = { ...prev };
+          for (const v of list) {
+            if (next[v.id] === undefined) {
+              next[v.id] = v.liveEventsProviders ?? null;
+            }
+          }
+          return next;
+        });
       })
       .catch(() => setErr("Kon gebruikers niet laden"));
   }, []);
@@ -214,6 +235,20 @@ export default function ViewersPage() {
       .then((r) => r.json())
       .then((d) => setAllLiveLists(d.lists ?? []))
       .catch(() => undefined);
+    fetch("/api/v1/admin/settings/iptv", { credentials: "include" })
+      .then((r) => r.json())
+      .then((d) => {
+        const all: string[] = Array.isArray(d.liveEventProviders)
+          ? d.liveEventProviders.map((p: string) => String(p).toLowerCase())
+          : [];
+        const disabled = new Set(
+          Array.isArray(d.settings?.liveEventsDisabledProviders)
+            ? d.settings.liveEventsDisabledProviders.map((p: string) => String(p).toLowerCase())
+            : []
+        );
+        setGlobalEventProviders(all.filter((p) => !disabled.has(p)));
+      })
+      .catch(() => undefined);
   }, [load]);
 
   // Live updates via SSE (device link, login lock, CRUD). Geen interval-poll.
@@ -339,15 +374,20 @@ export default function ViewersPage() {
     }
   }
 
-  async function toggle(v: Viewer, field: "enabled" | "appAccess" | "iptvAccess") {
+  async function toggle(
+    v: Viewer,
+    field: "enabled" | "appAccess" | "iptvAccess" | "liveEventsEnabled"
+  ) {
     setActionId(v.id);
     setErr(null);
     try {
+      const current =
+        field === "liveEventsEnabled" ? v.liveEventsEnabled !== false : Boolean(v[field]);
       const res = await fetch(`/api/v1/admin/viewers/${v.id}`, {
         method: "PATCH",
         credentials: "include",
         headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ [field]: !v[field] }),
+        body: JSON.stringify({ [field]: !current }),
       });
       if (!res.ok) {
         const data = await res.json().catch(() => ({}));
@@ -359,6 +399,63 @@ export default function ViewersPage() {
     }
   }
 
+  function toggleEventProviderDraft(viewerId: string, provider: string) {
+    setEventProviderDrafts((prev) => {
+      const cur = prev[viewerId];
+      // null = all → start from full global list then toggle off
+      const base =
+        cur === null || cur === undefined
+          ? [...globalEventProviders]
+          : [...cur];
+      const next = base.includes(provider)
+        ? base.filter((p) => p !== provider)
+        : [...base, provider];
+      // Empty allowlist is stored as "all" — use Live Events toggle for none
+      if (next.length === 0) {
+        return prev;
+      }
+      // Selecting all again → store null (all)
+      if (
+        next.length === globalEventProviders.length &&
+        globalEventProviders.every((p) => next.includes(p))
+      ) {
+        return { ...prev, [viewerId]: null };
+      }
+      return { ...prev, [viewerId]: next };
+    });
+  }
+
+  async function saveEventProviders(v: Viewer) {
+    setActionId(v.id);
+    setMsg(null);
+    setErr(null);
+    try {
+      const draft =
+        eventProviderDrafts[v.id] !== undefined
+          ? eventProviderDrafts[v.id]
+          : v.liveEventsProviders ?? null;
+      const res = await fetch(`/api/v1/admin/viewers/${v.id}`, {
+        method: "PATCH",
+        credentials: "include",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ liveEventsProviders: draft }),
+      });
+      const data = await res.json().catch(() => ({}));
+      if (!res.ok) {
+        setErr(data.error?.message ?? "Providers opslaan mislukt");
+        return;
+      }
+      setEventProviderDrafts((prev) => ({
+        ...prev,
+        [v.id]: data.viewer?.liveEventsProviders ?? draft,
+      }));
+      setMsg("Live Events-providers opgeslagen");
+      load();
+    } finally {
+      setActionId(null);
+    }
+  }
+
   async function saveIptv(v: Viewer) {
     const form = iptvForms[v.id] ?? emptyIptvForm();
     setActionId(v.id);
@@ -1229,6 +1326,21 @@ export default function ViewersPage() {
                           <span />
                         </button>
                       </div>
+                      <div className="toggle-row">
+                        <div>
+                          <strong>Live Events</strong>
+                          <span className="muted">Events-tab in Android TV</span>
+                        </div>
+                        <button
+                          type="button"
+                          className={`switch ${selected.liveEventsEnabled !== false ? "on" : ""}`}
+                          disabled={actionId === selected.id || !selected.appAccess}
+                          onClick={() => void toggle(selected, "liveEventsEnabled")}
+                          aria-pressed={selected.liveEventsEnabled !== false}
+                        >
+                          <span />
+                        </button>
+                      </div>
                     </div>
                     <div className="detail-actions">
                       <button
@@ -1409,6 +1521,77 @@ export default function ViewersPage() {
                     </div>
                   </article>
 
+                  <article className="block">
+                    <header className="block-head">
+                      <h3>Live Events-providers</h3>
+                    </header>
+                    <p className="muted detail-copy">
+                      Beperk welke providers deze gebruiker ziet. Alles aangevinkt (of knop
+                      &quot;Alle providers&quot;) = alle globaal ingeschakelde providers.
+                      Cluster-breed uitgeschakelde providers staan hier niet. Voor geen
+                      events: zet Live Events hierboven uit.
+                    </p>
+                    {globalEventProviders.length === 0 ? (
+                      <p className="muted">
+                        Nog geen providers — configureer de Live Events-feed onder{" "}
+                        <Link href="/settings">Instellingen → TV</Link>.
+                      </p>
+                    ) : (
+                      <div className="check-rows">
+                        {globalEventProviders.map((p) => {
+                          const draft =
+                            eventProviderDrafts[selected.id] !== undefined
+                              ? eventProviderDrafts[selected.id]
+                              : selected.liveEventsProviders ?? null;
+                          const checked = draft === null || (draft?.includes(p) ?? false);
+                          return (
+                            <label
+                              key={p}
+                              className="field"
+                              style={{ display: "flex", gap: 8, alignItems: "center" }}
+                            >
+                              <input
+                                type="checkbox"
+                                checked={checked}
+                                disabled={
+                                  actionId === selected.id ||
+                                  selected.liveEventsEnabled === false
+                                }
+                                onChange={() => toggleEventProviderDraft(selected.id, p)}
+                              />
+                              <span style={{ fontFamily: "monospace", fontSize: "0.9rem" }}>
+                                {p}
+                              </span>
+                            </label>
+                          );
+                        })}
+                      </div>
+                    )}
+                    <div className="detail-actions">
+                      <button
+                        type="button"
+                        className="btn-primary"
+                        disabled={
+                          actionId === selected.id ||
+                          globalEventProviders.length === 0 ||
+                          selected.liveEventsEnabled === false
+                        }
+                        onClick={() => void saveEventProviders(selected)}
+                      >
+                        Providers opslaan
+                      </button>
+                      <button
+                        type="button"
+                        disabled={actionId === selected.id}
+                        onClick={() =>
+                          setEventProviderDrafts((prev) => ({ ...prev, [selected.id]: null }))
+                        }
+                      >
+                        Alle providers
+                      </button>
+                    </div>
+                  </article>
+
                   <article className="block">
                     <header className="block-head">
                       <h3>Stremio-addon</h3>
diff --git a/apps/android-tv/app/build.gradle.kts b/apps/android-tv/app/build.gradle.kts
index 5ba9c45..ad5cc54 100644
--- a/apps/android-tv/app/build.gradle.kts
+++ b/apps/android-tv/app/build.gradle.kts
@@ -20,8 +20,8 @@ android {
         applicationId = "nl.vonas.mediacluster.tv"
         minSdk = 24
         targetSdk = 36
-        versionCode = 114
-        versionName = "0.14.51"
+        versionCode = 117
+        versionName = "0.14.54"
         buildConfigField("String", "DEFAULT_API_BASE", "\"https://master.vonas.nl\"")
         ndk {
             abiFilters += listOf("arm64-v8a", "armeabi-v7a")
diff --git a/apps/android-tv/app/src/main/java/nl/vonas/mediacluster/tv/playback/PlayerFactory.kt b/apps/android-tv/app/src/main/java/nl/vonas/mediacluster/tv/playback/PlayerFactory.kt
index 1b5bfc6..ae2a1d0 100644
--- a/apps/android-tv/app/src/main/java/nl/vonas/mediacluster/tv/playback/PlayerFactory.kt
+++ b/apps/android-tv/app/src/main/java/nl/vonas/mediacluster/tv/playback/PlayerFactory.kt
@@ -426,8 +426,10 @@ private fun hexToBytes(hex: String): ByteArray {
         .replace("-", "")
         .replace(Regex("[\\s:]"), "")
         .lowercase()
-    require(clean.length == 32 && clean.all { it in "0123456789abcdef" }) {
-        "ongeldige ClearKey hex (verwacht 32 tekens): ${hex.take(20)}"
+    if (clean.length != 32 || clean.any { it !in "0123456789abcdef" }) {
+        throw IllegalArgumentException(
+            "ongeldige ClearKey hex (verwacht 32 tekens): ${hex.take(20)}",
+        )
     }
     return ByteArray(16) { i ->
         clean.substring(i * 2, i * 2 + 2).toInt(16).toByte()
diff --git a/apps/android-tv/app/src/main/java/nl/vonas/mediacluster/tv/ui/EventPlayerScreen.kt b/apps/android-tv/app/src/main/java/nl/vonas/mediacluster/tv/ui/EventPlayerScreen.kt
index 8e98839..90d9903 100644
--- a/apps/android-tv/app/src/main/java/nl/vonas/mediacluster/tv/ui/EventPlayerScreen.kt
+++ b/apps/android-tv/app/src/main/java/nl/vonas/mediacluster/tv/ui/EventPlayerScreen.kt
@@ -4,6 +4,7 @@ import android.view.ViewGroup
 import androidx.activity.compose.BackHandler
 import androidx.annotation.OptIn
 import androidx.compose.foundation.background
+import androidx.compose.foundation.focusable
 import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.fillMaxSize
@@ -17,7 +18,14 @@ import androidx.compose.runtime.remember
 import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.focus.FocusRequester
+import androidx.compose.ui.focus.focusRequester
 import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.input.key.Key
+import androidx.compose.ui.input.key.KeyEventType
+import androidx.compose.ui.input.key.key
+import androidx.compose.ui.input.key.onPreviewKeyEvent
+import androidx.compose.ui.input.key.type
 import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.text.font.FontWeight
 import androidx.compose.ui.unit.dp
@@ -26,15 +34,22 @@ import androidx.compose.ui.viewinterop.AndroidView
 import androidx.media3.common.PlaybackException
 import androidx.media3.common.Player
 import androidx.media3.common.util.UnstableApi
+import androidx.media3.exoplayer.ExoPlayer
 import androidx.media3.ui.PlayerView
 import androidx.tv.material3.ExperimentalTvMaterial3Api
 import androidx.tv.material3.Text
+import kotlinx.coroutines.CancellationException
 import kotlinx.coroutines.delay
+import kotlinx.coroutines.isActive
 import nl.vonas.mediacluster.tv.data.ApiClient
 import nl.vonas.mediacluster.tv.playback.buildLiveTvPlayer
 import nl.vonas.mediacluster.tv.playback.ensureAudioSelected
 import nl.vonas.mediacluster.tv.playback.liveMediaItem
 import nl.vonas.mediacluster.tv.ui.theme.McColors
+import java.util.concurrent.atomic.AtomicBoolean
+import java.util.concurrent.atomic.AtomicReference
+
+private const val ReadyTimeoutMs = 20_000L
 
 @OptIn(UnstableApi::class)
 @kotlin.OptIn(ExperimentalTvMaterial3Api::class)
@@ -45,28 +60,78 @@ fun EventPlayerScreen(
     onBack: () -> Unit,
 ) {
     val context = LocalContext.current
-    val player = remember { buildLiveTvPlayer(context) }
+    val playerRef = remember { AtomicReference<ExoPlayer?>(null) }
+    val player = remember {
+        buildLiveTvPlayer(context).also { playerRef.set(it) }
+    }
+    val rootFocus = remember { FocusRequester() }
+    val reachedReady = remember { AtomicBoolean(false) }
     var title by remember { mutableStateOf("Live event") }
     var loading by remember { mutableStateOf(true) }
     var error by remember { mutableStateOf<String?>(null) }
     var showChrome by remember { mutableStateOf(true) }
 
+    fun safeStopAndClear() {
+        runCatching {
+            player.playWhenReady = false
+            player.stop()
+            player.clearMediaItems()
+        }
+    }
+
     LaunchedEffect(eventId) {
         loading = true
         error = null
+        reachedReady.set(false)
+        showChrome = true
         try {
             val play = api.scheduleEventPlay(eventId)
+            if (!isActive) return@LaunchedEffect
             title = play.name
-            player.setMediaItem(liveMediaItem(play.streamUrl, play.format, play.drm))
-            player.prepare()
-            player.playWhenReady = true
+            val url = play.streamUrl.trim()
+            if (url.isEmpty()) {
+                error = "Geen stream-URL beschikbaar"
+                return@LaunchedEffect
+            }
+            if (play.drm == null || play.drm.keys.isEmpty()) {
+                error = "Encryptiesleutels ontbreken — stream start binnenkort"
+                return@LaunchedEffect
+            }
+            val item = try {
+                liveMediaItem(url, play.format, play.drm)
+            } catch (e: Exception) {
+                error = e.message ?: "Ongeldige DRM-sleutels"
+                return@LaunchedEffect
+            }
+            if (!isActive) return@LaunchedEffect
+            try {
+                player.setMediaItem(item)
+                player.prepare()
+                player.playWhenReady = true
+            } catch (e: Exception) {
+                error = e.message ?: "Kon speler niet starten"
+                safeStopAndClear()
+            }
+        } catch (e: CancellationException) {
+            throw e
         } catch (e: Exception) {
             error = e.message ?: "Kon event niet afspelen"
+            safeStopAndClear()
         } finally {
             loading = false
         }
     }
 
+    // Geen eindeloze zwart-scherm hang: toon fout als READY uitblijft.
+    LaunchedEffect(eventId, error, loading) {
+        if (error != null || loading) return@LaunchedEffect
+        delay(ReadyTimeoutMs)
+        if (!reachedReady.get() && error == null) {
+            error = "Stream start niet (timeout). Druk op Terug."
+            safeStopAndClear()
+        }
+    }
+
     LaunchedEffect(showChrome, error, loading) {
         if (showChrome && error == null && !loading) {
             delay(4_000)
@@ -74,20 +139,45 @@ fun EventPlayerScreen(
         }
     }
 
+    LaunchedEffect(Unit) {
+        delay(80)
+        runCatching { rootFocus.requestFocus() }
+    }
+
     DisposableEffect(Unit) {
         val listener = object : Player.Listener {
             override fun onPlaybackStateChanged(state: Int) {
-                if (state == Player.STATE_READY) player.ensureAudioSelected()
+                when (state) {
+                    Player.STATE_READY -> {
+                        reachedReady.set(true)
+                        runCatching { player.ensureAudioSelected() }
+                    }
+                    else -> Unit
+                }
             }
 
             override fun onPlayerError(e: PlaybackException) {
-                error = e.message ?: "Afspeelfout"
+                val cause = generateSequence(e as Throwable?) { it.cause }
+                    .mapNotNull { it.message?.takeIf { m -> m.isNotBlank() } }
+                    .distinct()
+                    .take(3)
+                    .joinToString(" → ")
+                error = listOfNotNull(e.errorCodeName, cause.takeIf { it.isNotBlank() })
+                    .joinToString(": ")
+                    .ifBlank { e.message ?: "Afspeelfout" }
+                safeStopAndClear()
             }
         }
         player.addListener(listener)
         onDispose {
             player.removeListener(listener)
-            player.release()
+            runCatching {
+                player.playWhenReady = false
+                player.stop()
+                player.clearMediaItems()
+            }
+            runCatching { player.release() }
+            playerRef.compareAndSet(player, null)
         }
     }
 
@@ -96,22 +186,38 @@ fun EventPlayerScreen(
     Box(
         Modifier
             .fillMaxSize()
-            .background(Color.Black),
-    ) {
-        AndroidView(
-            factory = { ctx ->
-                PlayerView(ctx).apply {
-                    useController = false
-                    layoutParams = ViewGroup.LayoutParams(
-                        ViewGroup.LayoutParams.MATCH_PARENT,
-                        ViewGroup.LayoutParams.MATCH_PARENT,
-                    )
-                    this.player = player
+            .background(Color.Black)
+            .focusRequester(rootFocus)
+            .focusable()
+            .onPreviewKeyEvent { ev ->
+                if (ev.type == KeyEventType.KeyDown &&
+                    (ev.key == Key.Back || ev.key == Key.Escape)
+                ) {
+                    onBack()
+                    true
+                } else {
+                    false
                 }
             },
-            update = { it.player = player },
-            modifier = Modifier.fillMaxSize(),
-        )
+    ) {
+        if (error == null) {
+            AndroidView(
+                factory = { ctx ->
+                    PlayerView(ctx).apply {
+                        useController = false
+                        layoutParams = ViewGroup.LayoutParams(
+                            ViewGroup.LayoutParams.MATCH_PARENT,
+                            ViewGroup.LayoutParams.MATCH_PARENT,
+                        )
+                        this.player = playerRef.get()
+                    }
+                },
+                update = { view ->
+                    view.player = playerRef.get()
+                },
+                modifier = Modifier.fillMaxSize(),
+            )
+        }
 
         if (loading) {
             Box(Modifier.fillMaxSize(), contentAlignment = Alignment.Center) {
@@ -121,9 +227,24 @@ fun EventPlayerScreen(
         if (error != null) {
             Box(Modifier.fillMaxSize(), contentAlignment = Alignment.Center) {
                 Column(horizontalAlignment = Alignment.CenterHorizontally) {
-                    Text("Kan event niet afspelen", color = Color.White, fontWeight = FontWeight.Bold, fontSize = 22.sp)
-                    Text(error!!, color = McColors.Danger, fontSize = 15.sp, modifier = Modifier.padding(top = 8.dp))
-                    Text("Druk op Terug", color = McColors.TextDim, fontSize = 14.sp, modifier = Modifier.padding(top = 12.dp))
+                    Text(
+                        "Kan event niet afspelen",
+                        color = Color.White,
+                        fontWeight = FontWeight.Bold,
+                        fontSize = 22.sp,
+                    )
+                    Text(
+                        error!!,
+                        color = McColors.Danger,
+                        fontSize = 15.sp,
+                        modifier = Modifier.padding(top = 8.dp, start = 32.dp, end = 32.dp),
+                    )
+                    Text(
+                        "Druk op Terug",
+                        color = McColors.TextDim,
+                        fontSize = 14.sp,
+                        modifier = Modifier.padding(top = 12.dp),
+                    )
                 }
             }
         } else if (showChrome) {
diff --git a/apps/android-tv/app/src/main/java/nl/vonas/mediacluster/tv/ui/EventsScreen.kt b/apps/android-tv/app/src/main/java/nl/vonas/mediacluster/tv/ui/EventsScreen.kt
index 716fab0..b5c48a6 100644
--- a/apps/android-tv/app/src/main/java/nl/vonas/mediacluster/tv/ui/EventsScreen.kt
+++ b/apps/android-tv/app/src/main/java/nl/vonas/mediacluster/tv/ui/EventsScreen.kt
@@ -1,6 +1,8 @@
 package nl.vonas.mediacluster.tv.ui
 
 import androidx.activity.compose.BackHandler
+import androidx.compose.animation.Crossfade
+import androidx.compose.animation.core.tween
 import androidx.compose.foundation.background
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Box
@@ -11,31 +13,45 @@ import androidx.compose.foundation.layout.Spacer
 import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.heightIn
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.layout.size
 import androidx.compose.foundation.layout.width
 import androidx.compose.foundation.lazy.LazyColumn
 import androidx.compose.foundation.lazy.LazyRow
 import androidx.compose.foundation.lazy.items
+import androidx.compose.foundation.lazy.itemsIndexed
 import androidx.compose.foundation.lazy.rememberLazyListState
 import androidx.compose.foundation.shape.RoundedCornerShape
 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.DisposableEffect
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableIntStateOf
 import androidx.compose.runtime.mutableLongStateOf
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberCoroutineScope
 import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.clip
+import androidx.compose.foundation.focusable
 import androidx.compose.ui.focus.FocusRequester
+import androidx.compose.ui.focus.focusProperties
 import androidx.compose.ui.focus.focusRequester
 import androidx.compose.ui.focus.onFocusChanged
 import androidx.compose.ui.graphics.Brush
 import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.RectangleShape
+import androidx.compose.ui.input.key.Key
+import androidx.compose.ui.input.key.KeyEventType
+import androidx.compose.ui.input.key.key
+import androidx.compose.ui.input.key.onPreviewKeyEvent
+import androidx.compose.ui.input.key.type
 import androidx.compose.ui.layout.ContentScale
 import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.style.TextAlign
 import androidx.compose.ui.text.style.TextOverflow
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.unit.sp
@@ -46,6 +62,7 @@ import androidx.tv.material3.Surface
 import androidx.tv.material3.Text
 import coil.compose.AsyncImage
 import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
 import nl.vonas.mediacluster.tv.data.ApiClient
 import nl.vonas.mediacluster.tv.data.ScheduleEvent
 import nl.vonas.mediacluster.tv.ui.components.HomeChrome
@@ -62,11 +79,20 @@ private val ZoneNl: ZoneId = ZoneId.of("Europe/Amsterdam")
 private val TimeFmt: DateTimeFormatter = DateTimeFormatter.ofPattern("HH:mm")
 private val DayTimeFmt: DateTimeFormatter =
     DateTimeFormatter.ofPattern("EEE d MMM · HH:mm", Locale("nl", "NL"))
+private val StreamLabelRegex = Regex("""^stream\s*\d+""", RegexOption.IGNORE_CASE)
+private const val HeroRotateMs = 7_000L
+private const val HeroFadeMs = 850
 
 @OptIn(ExperimentalTvMaterial3Api::class)
 @Composable
 fun EventsScreen(
     api: ApiClient,
+    contentFocusRequester: FocusRequester,
+    navFocusRequester: FocusRequester,
+    focusRestoreNonce: Int = 0,
+    restoreEventId: String? = null,
+    pendingFocusRestore: Boolean = false,
+    onFocusRestoreConsumed: () -> Unit = {},
     onOpenEvent: (String) -> Unit,
     onPlayEvent: (String) -> Unit,
     onContentFocused: () -> Unit = {},
@@ -76,13 +102,17 @@ fun EventsScreen(
     var error by remember { mutableStateOf<String?>(null) }
     var providerFilter by remember { mutableStateOf<String?>(null) }
     var nowMs by remember { mutableLongStateOf(System.currentTimeMillis()) }
+    var heroFocusReady by remember { mutableStateOf(false) }
+    var railFocusReady by remember { mutableStateOf(false) }
     val listState = rememberLazyListState()
-    val heroFocus = remember { FocusRequester() }
+    val firstRailFocus = remember { FocusRequester() }
+    val restoreCardFocus = remember { FocusRequester() }
+    val scope = rememberCoroutineScope()
 
     suspend fun refresh() {
         runCatching { api.listScheduleEvents() }
             .onSuccess {
-                events = it.events
+                events = enrichEventImages(it.events)
                 error = null
             }
             .onFailure { error = it.message ?: "Kon events niet laden" }
@@ -91,7 +121,6 @@ fun EventsScreen(
 
     LaunchedEffect(Unit) {
         refresh()
-        runCatching { heroFocus.requestFocus() }
     }
     LaunchedEffect(Unit) {
         while (true) {
@@ -111,13 +140,128 @@ fun EventsScreen(
         else events.filter { it.provider.equals(providerFilter, ignoreCase = true) }
     }
     val live = remember(filtered) { filtered.filter { it.phase == "live" || it.isLive } }
-    val hero = live.firstOrNull { it.playable } ?: live.firstOrNull() ?: filtered.firstOrNull()
+    val liveHeroItems = remember(live) {
+        live.filter { it.playable }.ifEmpty { live }.take(8)
+    }
     val byDay = remember(filtered, nowMs) { groupEventsByDay(filtered) }
     val providers = remember(events) {
         events.map { it.provider }.distinct().sorted()
     }
+    val upcomingRails = remember(byDay) {
+        byDay.mapNotNull { (label, dayEvents) ->
+            val upcoming = dayEvents.filter { it.phase != "live" && !it.isLive }
+            if (upcoming.isEmpty()) null else label to upcoming
+        }
+    }
+    val restoreInLive = remember(live, restoreEventId) {
+        !restoreEventId.isNullOrBlank() && live.any { it.id == restoreEventId }
+    }
+    val restoreInUpcoming = remember(upcomingRails, restoreEventId) {
+        !restoreEventId.isNullOrBlank() &&
+            upcomingRails.any { (_, day) -> day.any { it.id == restoreEventId } }
+    }
+    val canRestoreCard = restoreInLive || restoreInUpcoming
+
+    val firstRailListIndex = remember(providers, live, upcomingRails) {
+        var idx = 1 // after hero
+        if (providers.size > 1) idx++
+        if (live.isNotEmpty() || upcomingRails.isNotEmpty()) idx else -1
+    }
+    val restoreListIndex = remember(providers, live, upcomingRails, restoreEventId, restoreInLive) {
+        if (restoreEventId.isNullOrBlank()) return@remember -1
+        var idx = 1
+        if (providers.size > 1) idx++
+        if (restoreInLive) return@remember idx
+        if (live.isNotEmpty()) idx++
+        upcomingRails.forEachIndexed { i, (_, day) ->
+            if (day.any { it.id == restoreEventId }) return@remember idx + i
+        }
+        -1
+    }
+
+    suspend fun awaitRailReady(timeoutMs: Long = 900): Boolean {
+        val deadline = System.currentTimeMillis() + timeoutMs
+        while (!railFocusReady && System.currentTimeMillis() < deadline) {
+            delay(40)
+        }
+        return railFocusReady
+    }
+
+    fun focusFirstRail() {
+        scope.launch {
+            if (!awaitRailReady()) return@launch
+            runCatching {
+                if (firstRailListIndex >= 0) {
+                    listState.animateScrollToItem(firstRailListIndex)
+                    delay(40)
+                }
+                firstRailFocus.requestFocus()
+            }
+        }
+    }
+
+    // Na terugkeer van detail/player: focus één keer voorspelbaar herstellen.
+    LaunchedEffect(
+        pendingFocusRestore,
+        focusRestoreNonce,
+        filtered.isNotEmpty(),
+        heroFocusReady,
+        railFocusReady,
+        canRestoreCard,
+    ) {
+        if (!pendingFocusRestore || filtered.isEmpty() || !heroFocusReady) return@LaunchedEffect
+        if (canRestoreCard && !railFocusReady) return@LaunchedEffect
+        delay(80)
+        onContentFocused()
+        val scrolled = listState.firstVisibleItemIndex > 0 ||
+            listState.firstVisibleItemScrollOffset > 40
+        if (scrolled) {
+            runCatching { listState.scrollToItem(0) }
+            delay(40)
+        }
+        var focused = false
+        if (canRestoreCard) {
+            focused = runCatching {
+                val scrollTo = restoreListIndex.takeIf { it >= 0 } ?: firstRailListIndex
+                if (scrollTo >= 0) {
+                    listState.animateScrollToItem(scrollTo)
+                    delay(50)
+                }
+                restoreCardFocus.requestFocus()
+            }.isSuccess
+        }
+        if (!focused) {
+            delay(40)
+            runCatching { contentFocusRequester.requestFocus() }
+        }
+        onFocusRestoreConsumed()
+    }
+
+    // Placeholder→hero: als TopNav-down op de 1dp-box landde vóór de CTA klaar was.
+    var placeholderHadFocus by remember { mutableStateOf(false) }
+    LaunchedEffect(heroFocusReady) {
+        if (!heroFocusReady || !placeholderHadFocus) return@LaunchedEffect
+        delay(40)
+        onContentFocused()
+        runCatching { contentFocusRequester.requestFocus() }
+        placeholderHadFocus = false
+    }
 
     Box(Modifier.fillMaxSize().background(McColors.Bg)) {
+        // TopNav "down" moet altijd een geldig doel hebben (ook tijdens laden).
+        if (!heroFocusReady) {
+            Box(
+                Modifier
+                    .size(1.dp)
+                    .align(Alignment.TopStart)
+                    .focusRequester(contentFocusRequester)
+                    .focusable()
+                    .onFocusChanged {
+                        placeholderHadFocus = it.isFocused
+                        if (it.isFocused) onContentFocused()
+                    },
+            )
+        }
         when {
             loading && events.isEmpty() -> {
                 Box(Modifier.fillMaxSize(), contentAlignment = Alignment.Center) {
@@ -140,20 +284,26 @@ fun EventsScreen(
                     modifier = Modifier.fillMaxSize(),
                     contentPadding = PaddingValues(bottom = 48.dp),
                 ) {
-                    item {
-                        if (hero != null) {
+                    item(key = "hero") {
+                        if (liveHeroItems.isNotEmpty() || filtered.isNotEmpty()) {
                             EventHero(
-                                event = hero,
+                                events = liveHeroItems.ifEmpty {
+                                    listOfNotNull(filtered.firstOrNull())
+                                },
                                 nowMs = nowMs,
-                                focusRequester = heroFocus,
+                                focusRequester = contentFocusRequester,
+                                navFocusRequester = navFocusRequester,
+                                railFocusRequester = firstRailFocus.takeIf { railFocusReady },
+                                onFocusReady = { heroFocusReady = it },
                                 onFocus = onContentFocused,
-                                onOpen = { onOpenEvent(hero.id) },
-                                onPlay = { onPlayEvent(hero.id) },
+                                onOpen = { id -> onOpenEvent(id) },
+                                onPlay = { id -> onPlayEvent(id) },
+                                onRequestRailFocus = { focusFirstRail() },
                             )
                         }
                     }
                     if (providers.size > 1) {
-                        item {
+                        item(key = "providers") {
                             ProviderChips(
                                 providers = providers,
                                 selected = providerFilter,
@@ -162,24 +312,44 @@ fun EventsScreen(
                         }
                     }
                     if (live.isNotEmpty()) {
-                        item {
+                        item(key = "live") {
                             EventRail(
                                 title = "Nu live",
                                 events = live,
                                 nowMs = nowMs,
                                 onOpen = onOpenEvent,
-                                onFocus = onContentFocused,
+                                onFocus = {
+                                    onContentFocused()
+                                },
+                                firstItemFocusRequester = firstRailFocus.takeIf { live.isNotEmpty() },
+                                restoreEventId = restoreEventId.takeIf { restoreInLive },
+                                restoreFocusRequester = restoreCardFocus.takeIf { restoreInLive },
+                                focusUpTo = contentFocusRequester.takeIf { heroFocusReady },
+                                onFirstFocusReady = { ready ->
+                                    if (live.isNotEmpty()) railFocusReady = ready
+                                },
                             )
                         }
                     }
-                    byDay.forEach { (label, dayEvents) ->
-                        item {
+                    upcomingRails.forEachIndexed { index, (label, dayEvents) ->
+                        val isFirstUpcoming = live.isEmpty() && index == 0
+                        val railHasRestore = !restoreInLive &&
+                            restoreEventId != null &&
+                            dayEvents.any { it.id == restoreEventId }
+                        item(key = "day-$label") {
                             EventRail(
                                 title = label,
-                                events = dayEvents.filter { it.phase != "live" && !it.isLive },
+                                events = dayEvents,
                                 nowMs = nowMs,
                                 onOpen = onOpenEvent,
                                 onFocus = onContentFocused,
+                                firstItemFocusRequester = firstRailFocus.takeIf { isFirstUpcoming },
+                                restoreEventId = restoreEventId.takeIf { railHasRestore },
+                                restoreFocusRequester = restoreCardFocus.takeIf { railHasRestore },
+                                focusUpTo = contentFocusRequester.takeIf { heroFocusReady && isFirstUpcoming },
+                                onFirstFocusReady = { ready ->
+                                    if (isFirstUpcoming) railFocusReady = ready
+                                },
                             )
                         }
                     }
@@ -198,14 +368,23 @@ fun EventDetailScreen(
     onPlay: (String) -> Unit,
 ) {
     var event by remember { mutableStateOf<ScheduleEvent?>(null) }
+    var siblings by remember { mutableStateOf<List<ScheduleEvent>>(emptyList()) }
     var error by remember { mutableStateOf<String?>(null) }
     var nowMs by remember { mutableLongStateOf(System.currentTimeMillis()) }
     val playFocus = remember { FocusRequester() }
+    val backFocus = remember { FocusRequester() }
+    val galleryFocus = remember { FocusRequester() }
+    val listState = rememberLazyListState()
+    val scope = rememberCoroutineScope()
 
     LaunchedEffect(eventId) {
-        runCatching { api.getScheduleEvent(eventId) }
-            .onSuccess {
-                event = it
+        runCatching {
+            val list = api.listScheduleEvents()
+            siblings = enrichEventImages(list.events)
+            api.getScheduleEvent(eventId)
+        }
+            .onSuccess { raw ->
+                event = enrichSingleEvent(raw, siblings)
                 error = null
                 delay(80)
                 runCatching { playFocus.requestFocus() }
@@ -216,13 +395,42 @@ fun EventDetailScreen(
         while (true) {
             delay(30_000)
             nowMs = System.currentTimeMillis()
-            runCatching { api.getScheduleEvent(eventId) }.onSuccess { event = it }
+            runCatching { api.getScheduleEvent(eventId) }
+                .onSuccess { event = enrichSingleEvent(it, siblings) }
         }
     }
 
     BackHandler(onBack = onBack)
 
     val ev = event
+    val gallery = remember(ev) {
+        ev?.images?.distinct()?.filter {
+            it != ev.imageLandscape && it != ev.logoUrl
+        }?.take(12).orEmpty()
+    }
+    val hasGallery = gallery.isNotEmpty()
+    // Lazy items: 0=hero, 1=cta, 2?=desc, 3?=audio, last=gallery
+    val galleryListIndex = remember(ev, hasGallery) {
+        if (!hasGallery || ev == null) -1
+        else {
+            var idx = 2 // after hero + cta
+            if (!ev.description.isNullOrBlank() || !ev.subtitle.isNullOrBlank()) idx++
+            if (ev.audioLanguages.isNotEmpty()) idx++
+            idx
+        }
+    }
+
+    fun scrollToGallery() {
+        if (galleryListIndex < 0) return
+        scope.launch {
+            runCatching {
+                listState.animateScrollToItem(galleryListIndex)
+                delay(60)
+                galleryFocus.requestFocus()
+            }
+        }
+    }
+
     Box(Modifier.fillMaxSize().background(McColors.Bg)) {
         when {
             ev == null && error == null -> {
@@ -240,17 +448,23 @@ fun EventDetailScreen(
                 }
             }
             else -> {
-                LazyColumn(Modifier.fillMaxSize()) {
-                    item {
+                LazyColumn(
+                    state = listState,
+                    modifier = Modifier.fillMaxSize(),
+                    contentPadding = PaddingValues(bottom = 40.dp),
+                ) {
+                    item(key = "hero") {
                         Box(
                             Modifier
                                 .fillMaxWidth()
-                                .height(420.dp),
+                                .height(420.dp)
+                                .clip(RectangleShape),
                         ) {
                             AsyncImage(
-                                model = ev.imageLandscape ?: ev.images.firstOrNull(),
+                                model = eventArtUrl(ev),
                                 contentDescription = ev.name,
                                 contentScale = ContentScale.Crop,
+                                alignment = Alignment.TopCenter,
                                 modifier = Modifier.fillMaxSize(),
                             )
                             Box(
@@ -259,6 +473,7 @@ fun EventDetailScreen(
                                     .background(
                                         Brush.verticalGradient(
                                             listOf(
+                                                Color(0x44000000),
                                                 Color.Transparent,
                                                 Color(0x880B0B0B),
                                                 McColors.Bg,
@@ -281,16 +496,20 @@ fun EventDetailScreen(
                                     fontWeight = FontWeight.Bold,
                                     maxLines = 3,
                                     overflow = TextOverflow.Ellipsis,
+                                    lineHeight = 40.sp,
                                 )
                                 Spacer(Modifier.height(8.dp))
-                                Text(
-                                    metaLine(ev),
-                                    color = McColors.TextDim,
-                                    fontSize = 15.sp,
-                                    maxLines = 2,
-                                    overflow = TextOverflow.Ellipsis,
-                                )
-                                Spacer(Modifier.height(6.dp))
+                                val meta = metaLine(ev)
+                                if (meta.isNotBlank()) {
+                                    Text(
+                                        meta,
+                                        color = McColors.TextDim,
+                                        fontSize = 15.sp,
+                                        maxLines = 2,
+                                        overflow = TextOverflow.Ellipsis,
+                                    )
+                                    Spacer(Modifier.height(6.dp))
+                                }
                                 Text(
                                     timeWindowLabel(ev),
                                     color = McColors.Text,
@@ -304,18 +523,18 @@ fun EventDetailScreen(
                                     contentDescription = null,
                                     modifier = Modifier
                                         .align(Alignment.TopEnd)
-                                        .padding(HomeChrome.EdgeInset)
-                                        .height(48.dp)
-                                        .width(120.dp),
+                                        .padding(top = 24.dp, end = HomeChrome.EdgeInset)
+                                        .height(44.dp)
+                                        .width(110.dp),
                                     contentScale = ContentScale.Fit,
                                 )
                             }
                         }
                     }
-                    item {
+                    item(key = "cta") {
                         Row(
                             Modifier.padding(horizontal = HomeChrome.EdgeInset),
-                            horizontalArrangement = Arrangement.spacedBy(14.dp),
+                            horizontalArrangement = Arrangement.spacedBy(12.dp),
                             verticalAlignment = Alignment.CenterVertically,
                         ) {
                             if (ev.playable) {
@@ -323,6 +542,7 @@ fun EventDetailScreen(
                                     "Kijk live",
                                     primary = true,
                                     focusRequester = playFocus,
+                                    onFocusDownFallback = if (hasGallery) ({ scrollToGallery() }) else null,
                                     onClick = { onPlay(ev.id) },
                                 )
                             } else {
@@ -331,15 +551,25 @@ fun EventDetailScreen(
                                     primary = false,
                                     enabled = false,
                                     focusRequester = playFocus,
+                                    onFocusDownFallback = if (hasGallery) ({ scrollToGallery() }) else null,
                                     onClick = {},
                                 )
                             }
-                            McDetailButton("Terug", onClick = onBack)
+                            McDetailButton(
+                                "Terug",
+                                focusRequester = backFocus,
+                                onFocusDownFallback = if (hasGallery) ({ scrollToGallery() }) else null,
+                                onClick = onBack,
+                            )
                         }
                     }
                     if (!ev.description.isNullOrBlank() || !ev.subtitle.isNullOrBlank()) {
-                        item {
-                            Column(Modifier.padding(HomeChrome.EdgeInset).padding(top = 22.dp)) {
+                        item(key = "desc") {
+                            Column(
+                                Modifier
+                                    .padding(HomeChrome.EdgeInset)
+                                    .padding(top = 22.dp),
+                            ) {
                                 if (!ev.eventType.isNullOrBlank() || !ev.subtitle.isNullOrBlank()) {
                                     Text(
                                         listOfNotNull(ev.eventType, ev.subtitle)
@@ -361,7 +591,7 @@ fun EventDetailScreen(
                         }
                     }
                     if (ev.audioLanguages.isNotEmpty()) {
-                        item {
+                        item(key = "audio") {
                             Column(Modifier.padding(HomeChrome.EdgeInset).padding(top = 18.dp)) {
                                 Text("Audio", color = McColors.TextDim, fontSize = 13.sp)
                                 Spacer(Modifier.height(8.dp))
@@ -380,11 +610,8 @@ fun EventDetailScreen(
                             }
                         }
                     }
-                    val gallery = ev.images.distinct().filter {
-                        it != ev.imageLandscape && it != ev.logoUrl
-                    }.take(12)
-                    if (gallery.isNotEmpty()) {
-                        item {
+                    if (hasGallery) {
+                        item(key = "gallery") {
                             Column(Modifier.padding(top = 28.dp)) {
                                 Text(
                                     "Beelden",
@@ -398,23 +625,69 @@ fun EventDetailScreen(
                                     contentPadding = PaddingValues(horizontal = HomeChrome.EdgeInset),
                                     horizontalArrangement = Arrangement.spacedBy(12.dp),
                                 ) {
-                                    items(gallery) { url ->
-                                        AsyncImage(
-                                            model = url,
-                                            contentDescription = null,
-                                            contentScale = ContentScale.Crop,
+                                    itemsIndexed(gallery) { index, url ->
+                                        var focused by remember { mutableStateOf(false) }
+                                        Surface(
+                                            onClick = {},
                                             modifier = Modifier
                                                 .width(220.dp)
                                                 .height(124.dp)
-                                                .clip(RoundedCornerShape(10.dp)),
-                                        )
+                                                .then(
+                                                    if (index == 0) {
+                                                        Modifier.focusRequester(galleryFocus)
+                                                    } else {
+                                                        Modifier
+                                                    },
+                                                )
+                                                .focusProperties {
+                                                    up = playFocus
+                                                }
+                                                .onFocusChanged {
+                                                    focused = it.isFocused
+                                                    if (it.isFocused) {
+                                                        scope.launch {
+                                                            runCatching {
+                                                                listState.animateScrollToItem(
+                                                                    galleryListIndex.coerceAtLeast(0),
+                                                                )
+                                                            }
+                                                        }
+                                                    }
+                                                },
+                                            scale = ClickableSurfaceDefaults.scale(focusedScale = 1.05f),
+                                            glow = ClickableSurfaceDefaults.glow(
+                                                focusedGlow = Glow(
+                                                    elevationColor = McColors.Accent,
+                                                    elevation = 6.dp,
+                                                ),
+                                            ),
+                                            colors = ClickableSurfaceDefaults.colors(
+                                                containerColor = McColors.Surface,
+                                                focusedContainerColor = McColors.Surface,
+                                            ),
+                                            shape = ClickableSurfaceDefaults.shape(RoundedCornerShape(10.dp)),
+                                        ) {
+                                            AsyncImage(
+                                                model = url,
+                                                contentDescription = null,
+                                                contentScale = ContentScale.Crop,
+                                                modifier = Modifier.fillMaxSize(),
+                                            )
+                                            if (focused) {
+                                                Box(
+                                                    Modifier
+                                                        .fillMaxSize()
+                                                        .background(Color(0x22000000)),
+                                                )
+                                            }
+                                        }
                                     }
                                 }
                                 Spacer(Modifier.height(40.dp))
                             }
                         }
                     } else {
-                        item { Spacer(Modifier.height(40.dp)) }
+                        item(key = "spacer") { Spacer(Modifier.height(40.dp)) }
                     }
                 }
             }
@@ -422,70 +695,216 @@ fun EventDetailScreen(
     }
 }
 
+/**
+ * Full-bleed artwork under semi-transparant TopNav; badge/title/meta start at [HomeChrome.BadgeTop].
+ * Auto-rotates live heroes with a soft Crossfade; CTA focus stays stable outside the fade key.
+ */
 @OptIn(ExperimentalTvMaterial3Api::class)
 @Composable
 private fun EventHero(
-    event: ScheduleEvent,
+    events: List<ScheduleEvent>,
     nowMs: Long,
     focusRequester: FocusRequester,
+    navFocusRequester: FocusRequester,
+    railFocusRequester: FocusRequester?,
+    onFocusReady: (Boolean) -> Unit,
     onFocus: () -> Unit,
-    onOpen: () -> Unit,
-    onPlay: () -> Unit,
+    onOpen: (String) -> Unit,
+    onPlay: (String) -> Unit,
+    onRequestRailFocus: () -> Unit = {},
 ) {
+    if (events.isEmpty()) return
+    var heroIndex by remember { mutableIntStateOf(0) }
+    val idsKey = remember(events) { events.joinToString("|") { it.id } }
+
+    LaunchedEffect(idsKey) {
+        heroIndex = 0
+        if (events.size <= 1) return@LaunchedEffect
+        while (true) {
+            delay(HeroRotateMs)
+            heroIndex = (heroIndex + 1) % events.size
+        }
+    }
+
+    val safeIndex = heroIndex.coerceIn(0, events.lastIndex)
+    val current = events[safeIndex]
+
     Box(
         Modifier
             .fillMaxWidth()
-            .height(460.dp),
+            .height(480.dp)
+            .clip(RectangleShape)
+            .background(Color(0xFF0B0B0B)),
     ) {
-        AsyncImage(
-            model = event.imageLandscape ?: event.images.firstOrNull(),
-            contentDescription = event.name,
-            contentScale = ContentScale.Crop,
-            modifier = Modifier.fillMaxSize(),
-        )
-        Box(Modifier.fillMaxSize().background(McColors.HeroScrim))
+        Crossfade(
+            targetState = current.id,
+            animationSpec = tween(HeroFadeMs),
+            label = "event-hero-art",
+        ) { id ->
+            val event = events.find { it.id == id } ?: current
+            Box(Modifier.fillMaxSize()) {
+                AsyncImage(
+                    model = eventArtUrl(event),
+                    contentDescription = event.name,
+                    contentScale = ContentScale.Crop,
+                    alignment = Alignment.TopCenter,
+                    modifier = Modifier.fillMaxSize(),
+                )
+                Box(
+                    Modifier.fillMaxSize().background(
+                        Brush.horizontalGradient(
+                            0.0f to Color(0xCC0B0B0B),
+                            0.42f to Color(0x660B0B0B),
+                            0.78f to Color(0x180B0B0B),
+                            1.0f to Color.Transparent,
+                        ),
+                    ),
+                )
+                Box(
+                    Modifier.fillMaxSize().background(
+                        Brush.verticalGradient(
+                            0.0f to Color(0x44000000),
+                            0.12f to Color.Transparent,
+                            0.48f to Color.Transparent,
+                            0.78f to Color(0x990B0B0B),
+                            1.0f to Color(0xFF0B0B0B),
+                        ),
+                    ),
+                )
+            }
+        }
+
         Column(
             Modifier
-                .align(Alignment.BottomStart)
-                .padding(start = HomeChrome.EdgeInset, end = 80.dp, bottom = 36.dp)
-                .fillMaxWidth(0.65f),
+                .fillMaxSize()
+                .padding(top = HomeChrome.BadgeTop)
+                .padding(start = HomeChrome.EdgeInset, end = HomeChrome.EdgeInset, bottom = 32.dp),
+            verticalArrangement = Arrangement.Top,
         ) {
-            StatusBadge(event, nowMs)
-            Spacer(Modifier.height(12.dp))
-            Text(
-                event.name,
-                color = McColors.Text,
-                fontSize = 36.sp,
-                fontWeight = FontWeight.Bold,
-                maxLines = 2,
-                overflow = TextOverflow.Ellipsis,
-            )
-            Spacer(Modifier.height(8.dp))
-            Text(
-                metaLine(event),
-                color = McColors.TextDim,
-                fontSize = 15.sp,
-                maxLines = 1,
-                overflow = TextOverflow.Ellipsis,
-            )
-            Spacer(Modifier.height(4.dp))
-            Text(timeWindowLabel(event), color = McColors.Text, fontSize = 15.sp)
-            Spacer(Modifier.height(18.dp))
-            Row(horizontalArrangement = Arrangement.spacedBy(12.dp)) {
-                if (event.playable) {
+            Crossfade(
+                targetState = current.id,
+                animationSpec = tween(HeroFadeMs),
+                label = "event-hero-meta",
+                modifier = Modifier.fillMaxWidth(0.62f),
+            ) { id ->
+                val event = events.find { it.id == id } ?: current
+                Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
+                    StatusBadge(event, nowMs)
+                    Text(
+                        event.name,
+                        color = Color.White,
+                        fontSize = 36.sp,
+                        fontWeight = FontWeight.Bold,
+                        maxLines = 2,
+                        overflow = TextOverflow.Ellipsis,
+                        lineHeight = 42.sp,
+                    )
+                    val meta = metaLine(event)
+                    if (meta.isNotBlank()) {
+                        Text(
+                            meta,
+                            color = Color(0xFFCFCFCF),
+                            fontSize = 15.sp,
+                            maxLines = 1,
+                            overflow = TextOverflow.Ellipsis,
+                        )
+                    }
+                    Text(
+                        timeWindowLabel(event),
+                        color = McColors.Text,
+                        fontSize = 15.sp,
+                    )
+                }
+            }
+
+            Spacer(Modifier.height(16.dp))
+
+            // CTAs buiten Crossfade → FocusRequester blijft stabiel tijdens rotate
+            Row(horizontalArrangement = Arrangement.spacedBy(10.dp)) {
+                DisposableEffect(focusRequester) {
+                    onFocusReady(true)
+                    onDispose { onFocusReady(false) }
+                }
+                if (current.playable) {
                     McDetailButton(
                         "Kijk live",
                         primary = true,
                         focusRequester = focusRequester,
+                        focusUp = navFocusRequester,
+                        focusDown = railFocusRequester,
                         onFocus = onFocus,
-                        onClick = onPlay,
+                        onFocusDownFallback = if (railFocusRequester == null) {
+                            ({ onRequestRailFocus() })
+                        } else {
+                            null
+                        },
+                        onClick = { onPlay(current.id) },
+                    )
+                    McDetailButton(
+                        "Meer info",
+                        focusUp = navFocusRequester,
+                        focusDown = railFocusRequester,
+                        onFocus = onFocus,
+                        onFocusDownFallback = if (railFocusRequester == null) {
+                            ({ onRequestRailFocus() })
+                        } else {
+                            null
+                        },
+                        onClick = { onOpen(current.id) },
+                    )
+                } else {
+                    McDetailButton(
+                        ctaLabel(current, nowMs),
+                        primary = true,
+                        focusRequester = focusRequester,
+                        focusUp = navFocusRequester,
+                        focusDown = railFocusRequester,
+                        onFocus = onFocus,
+                        onFocusDownFallback = if (railFocusRequester == null) {
+                            ({ onRequestRailFocus() })
+                        } else {
+                            null
+                        },
+                        onClick = { onOpen(current.id) },
                     )
                 }
-                McDetailButton(
-                    if (event.playable) "Meer info" else ctaLabel(event, nowMs),
-                    focusRequester = if (!event.playable) focusRequester else null,
-                    onFocus = onFocus,
-                    onClick = onOpen,
+            }
+
+            if (events.size > 1) {
+                Spacer(Modifier.height(14.dp))
+                Row(horizontalArrangement = Arrangement.spacedBy(6.dp)) {
+                    events.forEachIndexed { i, _ ->
+                        Box(
+                            Modifier
+                                .width(if (i == safeIndex) 18.dp else 8.dp)
+                                .height(3.dp)
+                                .clip(RoundedCornerShape(2.dp))
+                                .background(
+                                    if (i == safeIndex) Color.White else Color(0x55FFFFFF),
+                                ),
+                        )
+                    }
+                }
+            }
+        }
+
+        Crossfade(
+            targetState = current.logoUrl,
+            animationSpec = tween(HeroFadeMs),
+            label = "event-hero-logo",
+            modifier = Modifier
+                .align(Alignment.TopEnd)
+                .padding(top = HomeChrome.BadgeTop, end = HomeChrome.EdgeInset),
+        ) { logo ->
+            if (!logo.isNullOrBlank()) {
+                AsyncImage(
+                    model = logo,
+                    contentDescription = null,
+                    modifier = Modifier
+                        .height(48.dp)
+                        .width(120.dp),
+                    contentScale = ContentScale.Fit,
+                    alignment = Alignment.CenterEnd,
                 )
             }
         }
@@ -500,9 +919,24 @@ private fun EventRail(
     nowMs: Long,
     onOpen: (String) -> Unit,
     onFocus: () -> Unit,
+    firstItemFocusRequester: FocusRequester? = null,
+    restoreEventId: String? = null,
+    restoreFocusRequester: FocusRequester? = null,
+    focusUpTo: FocusRequester? = null,
+    onFirstFocusReady: ((Boolean) -> Unit)? = null,
 ) {
     if (events.isEmpty()) return
-    Column(Modifier.padding(top = 22.dp)) {
+    val rowState = rememberLazyListState()
+    val restoreIndex = remember(events, restoreEventId) {
+        if (restoreEventId.isNullOrBlank()) -1
+        else events.indexOfFirst { it.id == restoreEventId }
+    }
+    LaunchedEffect(restoreIndex) {
+        if (restoreIndex > 0) {
+            runCatching { rowState.scrollToItem(restoreIndex) }
+        }
+    }
+    Column(Modifier.padding(top = 20.dp)) {
         Text(
             title,
             color = McColors.Text,
@@ -512,11 +946,38 @@ private fun EventRail(
         )
         Spacer(Modifier.height(12.dp))
         LazyRow(
+            state = rowState,
             contentPadding = PaddingValues(horizontal = HomeChrome.EdgeInset),
             horizontalArrangement = Arrangement.spacedBy(14.dp),
         ) {
             items(events, key = { it.id }) { ev ->
-                EventCard(ev, nowMs, onOpen = { onOpen(ev.id) }, onFocus = onFocus)
+                val isFirst = ev.id == events.first().id
+                val isRestore = restoreEventId != null && ev.id == restoreEventId
+                if (isFirst && firstItemFocusRequester != null) {
+                    DisposableEffect(firstItemFocusRequester) {
+                        onFirstFocusReady?.invoke(true)
+                        onDispose { onFirstFocusReady?.invoke(false) }
+                    }
+                }
+                val cardRequester = when {
+                    isRestore && restoreFocusRequester != null -> restoreFocusRequester
+                    isFirst -> firstItemFocusRequester
+                    else -> null
+                }
+                EventCard(
+                    event = ev,
+                    nowMs = nowMs,
+                    onOpen = { onOpen(ev.id) },
+                    onFocus = onFocus,
+                    focusRequester = cardRequester,
+                    extraFocusRequester = when {
+                        isRestore && isFirst && firstItemFocusRequester != null &&
+                            restoreFocusRequester != null &&
+                            firstItemFocusRequester !== restoreFocusRequester -> firstItemFocusRequester
+                        else -> null
+                    },
+                    focusUp = focusUpTo.takeIf { isFirst || isRestore },
+                )
             }
         }
     }
@@ -529,12 +990,24 @@ private fun EventCard(
     nowMs: Long,
     onOpen: () -> Unit,
     onFocus: () -> Unit,
+    focusRequester: FocusRequester? = null,
+    extraFocusRequester: FocusRequester? = null,
+    focusUp: FocusRequester? = null,
 ) {
     var focused by remember { mutableStateOf(false) }
     Surface(
         onClick = onOpen,
         modifier = Modifier
             .width(280.dp)
+            .then(if (focusRequester != null) Modifier.focusRequester(focusRequester) else Modifier)
+            .then(if (extraFocusRequester != null) Modifier.focusRequester(extraFocusRequester) else Modifier)
+            .then(
+                if (focusUp != null) {
+                    Modifier.focusProperties { up = focusUp }
+                } else {
+                    Modifier
+                },
+            )
             .onFocusChanged {
                 focused = it.isFocused
                 if (it.isFocused) onFocus()
@@ -553,14 +1026,36 @@ private fun EventCard(
             Box(
                 Modifier
                     .fillMaxWidth()
-                    .height(158.dp),
+                    .height(158.dp)
+                    .background(Color(0xFF1A1A1A)),
             ) {
-                AsyncImage(
-                    model = event.imageLandscape ?: event.imagePortrait ?: event.images.firstOrNull(),
-                    contentDescription = event.name,
-                    contentScale = ContentScale.Crop,
-                    modifier = Modifier.fillMaxSize(),
-                )
+                val art = eventArtUrl(event)
+                if (art != null) {
+                    AsyncImage(
+                        model = art,
+                        contentDescription = event.name,
+                        contentScale = ContentScale.Crop,
+                        modifier = Modifier.fillMaxSize(),
+                    )
+                } else {
+                    Box(
+                        Modifier
+                            .fillMaxSize()
+                            .background(
+                                Brush.linearGradient(
+                                    listOf(Color(0xFF252530), Color(0xFF121218)),
+                                ),
+                            ),
+                        contentAlignment = Alignment.Center,
+                    ) {
+                        Text(
+                            prettyProvider(event.provider),
+                            color = McColors.TextDim,
+                            fontSize = 13.sp,
+                            fontWeight = FontWeight.Medium,
+                        )
+                    }
+                }
                 Box(
                     Modifier
                         .align(Alignment.TopStart)
@@ -577,14 +1072,16 @@ private fun EventCard(
                     fontWeight = FontWeight.SemiBold,
                     maxLines = 2,
                     overflow = TextOverflow.Ellipsis,
-                    modifier = Modifier.height(42.dp),
+                    lineHeight = 18.sp,
+                    modifier = Modifier.height(40.dp),
                 )
                 Spacer(Modifier.height(4.dp))
                 Text(
                     listOfNotNull(
                         prettyProvider(event.provider),
+                        displayChannel(event),
                         shortTimeLabel(event, nowMs),
-                    ).joinToString(" · "),
+                    ).distinct().joinToString(" · "),
                     color = McColors.TextDim,
                     fontSize = 12.sp,
                     maxLines = 1,
@@ -602,7 +1099,7 @@ private fun ProviderChips(
     onSelect: (String?) -> Unit,
 ) {
     LazyRow(
-        contentPadding = PaddingValues(horizontal = HomeChrome.EdgeInset, vertical = 16.dp),
+        contentPadding = PaddingValues(horizontal = HomeChrome.EdgeInset, vertical = 14.dp),
         horizontalArrangement = Arrangement.spacedBy(8.dp),
     ) {
         item {
@@ -666,44 +1163,83 @@ private fun McDetailButton(
     primary: Boolean = false,
     enabled: Boolean = true,
     focusRequester: FocusRequester? = null,
+    focusUp: FocusRequester? = null,
+    focusDown: FocusRequester? = null,
     onFocus: (() -> Unit)? = null,
+    /** When gallery/rail is off-screen, scroll+focus before default D-pad move. */
+    onFocusDownFallback: (() -> Unit)? = null,
 ) {
-    var focused by remember { mutableStateOf(false) }
     val mod = Modifier
         .then(if (focusRequester != null) Modifier.focusRequester(focusRequester) else Modifier)
+        .then(
+            if (focusUp != null || (focusDown != null && onFocusDownFallback == null)) {
+                Modifier.focusProperties {
+                    focusUp?.let { up = it }
+                    if (onFocusDownFallback == null) {
+                        focusDown?.let { down = it }
+                    }
+                }
+            } else {
+                Modifier
+            },
+        )
+        .then(
+            if (onFocusDownFallback != null) {
+                Modifier.onPreviewKeyEvent { ev ->
+                    if (ev.type == KeyEventType.KeyDown && ev.key == Key.DirectionDown) {
+                        onFocusDownFallback()
+                        true
+                    } else {
+                        false
+                    }
+                }
+            } else {
+                Modifier
+            },
+        )
         .onFocusChanged {
-            focused = it.isFocused
             if (it.isFocused) onFocus?.invoke()
         }
-        .height(48.dp)
+        .heightIn(min = 36.dp, max = 40.dp)
     Surface(
-        onClick = { if (enabled) onClick() },
+        onClick = {
+            if (enabled) onClick()
+        },
         enabled = enabled,
         modifier = mod,
-        scale = ClickableSurfaceDefaults.scale(focusedScale = 1.05f),
+        scale = ClickableSurfaceDefaults.scale(focusedScale = 1.06f),
         colors = ClickableSurfaceDefaults.colors(
             containerColor = when {
                 !enabled -> McColors.Surface.copy(alpha = 0.55f)
                 primary -> McColors.Accent
-                else -> McColors.Surface
+                else -> Color(0x33FFFFFF)
             },
             focusedContainerColor = when {
                 !enabled -> McColors.Surface
                 primary -> Color.White
-                else -> McColors.SurfaceFocus
+                else -> Color.White
             },
             contentColor = Color.White,
-            focusedContentColor = if (primary && enabled) Color.Black else Color.Black,
+            focusedContentColor = Color.Black,
             disabledContainerColor = McColors.Surface.copy(alpha = 0.45f),
             disabledContentColor = McColors.TextDim,
         ),
-        shape = ClickableSurfaceDefaults.shape(RoundedCornerShape(8.dp)),
+        shape = ClickableSurfaceDefaults.shape(RoundedCornerShape(4.dp)),
     ) {
         Box(
-            Modifier.padding(horizontal = 22.dp),
+            Modifier
+                .heightIn(min = 36.dp)
+                .padding(horizontal = 16.dp, vertical = 8.dp),
             contentAlignment = Alignment.Center,
         ) {
-            Text(label, fontWeight = FontWeight.SemiBold, fontSize = 15.sp)
+            Text(
+                label,
+                fontWeight = FontWeight.SemiBold,
+                fontSize = 13.sp,
+                textAlign = TextAlign.Center,
+                maxLines = 1,
+                overflow = TextOverflow.Ellipsis,
+            )
         }
     }
 }
@@ -751,13 +1287,30 @@ private fun timeWindowLabel(event: ScheduleEvent): String {
     return "${start.format(TimeFmt)} – ${stop.format(TimeFmt)}"
 }
 
+private fun isStreamLabel(value: String?): Boolean {
+    val s = value?.trim().orEmpty()
+    if (s.isEmpty()) return false
+    return StreamLabelRegex.containsMatchIn(s)
+}
+
+private fun displayChannel(event: ScheduleEvent): String? {
+    val raw = event.channel?.takeIf { it.isNotBlank() } ?: event.network
+    return raw?.takeIf { !isStreamLabel(it) }
+}
+
 private fun metaLine(event: ScheduleEvent): String =
     listOfNotNull(
         prettyProvider(event.provider),
         event.eventType,
-        event.channel ?: event.network,
+        displayChannel(event),
     ).joinToString(" · ")
 
+private fun eventArtUrl(event: ScheduleEvent): String? =
+    event.imageLandscape?.takeIf { it.isNotBlank() }
+        ?: event.images.firstOrNull { it.isNotBlank() && !it.contains("assets/channels", ignoreCase = true) }
+        ?: event.imagePortrait?.takeIf { it.isNotBlank() }
+        ?: event.images.firstOrNull()
+
 private fun prettyProvider(raw: String): String = when (raw.lowercase()) {
     "viaplay" -> "Viaplay"
     "ziggosport" -> "Ziggo Sport"
@@ -771,6 +1324,80 @@ private fun prettyProvider(raw: String): String = when (raw.lowercase()) {
     else -> raw.replace('_', ' ').replaceFirstChar { it.uppercase() }
 }
 
+private fun normalizeChannelKey(value: String?): String =
+    value?.trim()?.lowercase()?.replace(Regex("\\s+"), " ").orEmpty()
+
+private fun donorImageScore(e: ScheduleEvent): Int {
+    var s = 0
+    if (!e.imageLandscape.isNullOrBlank()) s += 20
+    if (e.images.any { it.contains("thumb", true) || it.contains("akamaized.net/live", true) }) s += 30
+    if (!e.logoUrl.isNullOrBlank()) s += 5
+    s += e.images.size.coerceAtMost(5)
+    if (e.provider.equals("ziggosport", true)) s += 8
+    if (e.playable) s += 3
+    return s
+}
+
+/** Client-side fallback: borrow artwork from another event on the same channel/network. */
+private fun enrichEventImages(events: List<ScheduleEvent>): List<ScheduleEvent> {
+    val donors = linkedMapOf<String, ScheduleEvent>()
+    for (e in events) {
+        if (e.imageLandscape.isNullOrBlank() && e.images.isEmpty() && e.logoUrl.isNullOrBlank()) continue
+        for (key in listOf(e.channel, e.network).map { normalizeChannelKey(it) }.filter { it.isNotEmpty() }) {
+            val existing = donors[key]
+            if (existing == null || donorImageScore(e) > donorImageScore(existing)) {
+                donors[key] = e
+            }
+        }
+    }
+    return events.map { e -> enrichSingleEvent(e, events, donors) }
+}
+
+private fun enrichSingleEvent(
+    e: ScheduleEvent,
+    siblings: List<ScheduleEvent>,
+    donors: Map<String, ScheduleEvent>? = null,
+): ScheduleEvent {
+    if (!e.imageLandscape.isNullOrBlank() || e.images.isNotEmpty()) {
+        return e.copy(
+            channel = e.channel?.takeIf { !isStreamLabel(it) },
+            network = e.network?.takeIf { !isStreamLabel(it) },
+        )
+    }
+    val map = donors ?: run {
+        val built = linkedMapOf<String, ScheduleEvent>()
+        for (sib in siblings) {
+            if (sib.imageLandscape.isNullOrBlank() && sib.images.isEmpty()) continue
+            for (key in listOf(sib.channel, sib.network).map { normalizeChannelKey(it) }.filter { it.isNotEmpty() }) {
+                val existing = built[key]
+                if (existing == null || donorImageScore(sib) > donorImageScore(existing)) {
+                    built[key] = sib
+                }
+            }
+        }
+        built
+    }
+    var donor: ScheduleEvent? = null
+    for (key in listOf(e.channel, e.network).map { normalizeChannelKey(it) }.filter { it.isNotEmpty() }) {
+        val hit = map[key]
+        if (hit != null && hit.id != e.id) {
+            donor = hit
+            break
+        }
+    }
+    val cleaned = e.copy(
+        channel = e.channel?.takeIf { !isStreamLabel(it) },
+        network = e.network?.takeIf { !isStreamLabel(it) },
+    )
+    if (donor == null) return cleaned
+    return cleaned.copy(
+        imageLandscape = cleaned.imageLandscape ?: donor.imageLandscape,
+        imagePortrait = cleaned.imagePortrait ?: donor.imagePortrait,
+        logoUrl = cleaned.logoUrl ?: donor.logoUrl,
+        images = cleaned.images.ifEmpty { donor.images },
+    )
+}
+
 private fun groupEventsByDay(events: List<ScheduleEvent>): List<Pair<String, List<ScheduleEvent>>> {
     val today = LocalDate.now(ZoneNl)
     val groups = linkedMapOf<String, MutableList<ScheduleEvent>>()
diff --git a/apps/android-tv/app/src/main/java/nl/vonas/mediacluster/tv/ui/McNav.kt b/apps/android-tv/app/src/main/java/nl/vonas/mediacluster/tv/ui/McNav.kt
index 6df512a..bbcb9e5 100644
--- a/apps/android-tv/app/src/main/java/nl/vonas/mediacluster/tv/ui/McNav.kt
+++ b/apps/android-tv/app/src/main/java/nl/vonas/mediacluster/tv/ui/McNav.kt
@@ -128,6 +128,9 @@ fun McNav() {
     var tvCategoryId by rememberSaveable { mutableStateOf<String?>(null) }
     var tvLastStreamId by rememberSaveable { mutableStateOf<String?>(null) }
     var tvFocusNonce by remember { mutableIntStateOf(0) }
+    var eventsReturnNonce by remember { mutableIntStateOf(0) }
+    var lastOpenedEventId by rememberSaveable { mutableStateOf<String?>(null) }
+    var pendingEventsFocusRestore by remember { mutableStateOf(false) }
     val favoriteIds by store.favoriteStreamIds.collectAsState(initial = emptySet())
     val hubTab = remember(hubTabName) {
         MainTab.entries.firstOrNull { it.name == hubTabName } ?: MainTab.Home
@@ -321,6 +324,10 @@ fun McNav() {
                 onToggleFavorite = { id -> scope.launch { store.toggleFavorite(id) } },
                 tvFocusNonce = tvFocusNonce,
                 onTvFocusContent = { tvFocusNonce++ },
+                eventsReturnNonce = eventsReturnNonce,
+                restoreEventId = lastOpenedEventId,
+                pendingEventsFocusRestore = pendingEventsFocusRestore,
+                onEventsFocusRestoreConsumed = { pendingEventsFocusRestore = false },
                 profileAvatarId = profileAvatarId,
                 profileShowAvatar = profileShowAvatar,
                 profileAvatarUrl = profileAvatarUrl,
@@ -342,10 +349,14 @@ fun McNav() {
                     nav.navigate("live/${android.net.Uri.encode(streamId)}")
                 },
                 onOpenEvent = { eventId ->
+                    lastOpenedEventId = eventId
                     nav.navigate("event/${android.net.Uri.encode(eventId)}")
                 },
                 onPlayEvent = { eventId ->
-                    nav.navigate("event_play/${android.net.Uri.encode(eventId)}")
+                    lastOpenedEventId = eventId
+                    nav.navigate("event_play/${android.net.Uri.encode(eventId)}") {
+                        launchSingleTop = true
+                    }
                 },
                 onSwitchProfile = {
                     scope.launch {
@@ -476,12 +487,21 @@ fun McNav() {
             val eventId = entry.arguments?.getString("eventId")
                 ?.let { android.net.Uri.decode(it) }
                 ?: return@composable
+            DisposableEffect(Unit) {
+                onDispose {
+                    pendingEventsFocusRestore = true
+                    eventsReturnNonce++
+                }
+            }
             EventDetailScreen(
                 api = api,
                 eventId = eventId,
                 onBack = { nav.popBackStack() },
                 onPlay = { id ->
-                    nav.navigate("event_play/${android.net.Uri.encode(id)}")
+                    lastOpenedEventId = id
+                    nav.navigate("event_play/${android.net.Uri.encode(id)}") {
+                        launchSingleTop = true
+                    }
                 },
             )
         }
@@ -492,6 +512,12 @@ fun McNav() {
             val eventId = entry.arguments?.getString("eventId")
                 ?.let { android.net.Uri.decode(it) }
                 ?: return@composable
+            DisposableEffect(Unit) {
+                onDispose {
+                    pendingEventsFocusRestore = true
+                    eventsReturnNonce++
+                }
+            }
             EventPlayerScreen(
                 api = api,
                 eventId = eventId,
@@ -519,6 +545,10 @@ private fun MainHub(
     onToggleFavorite: (String) -> Unit,
     tvFocusNonce: Int,
     onTvFocusContent: () -> Unit,
+    eventsReturnNonce: Int = 0,
+    restoreEventId: String? = null,
+    pendingEventsFocusRestore: Boolean = false,
+    onEventsFocusRestoreConsumed: () -> Unit = {},
     profileAvatarId: String?,
     profileShowAvatar: Boolean = true,
     profileAvatarUrl: String? = null,
@@ -544,6 +574,7 @@ private fun MainHub(
     var coldStartNavFocus by rememberSaveable { mutableStateOf(true) }
     val navFocus = remember { FocusRequester() }
     val homeContentFocus = remember { FocusRequester() }
+    val eventsContentFocus = remember { FocusRequester() }
     val exitFocus = remember { FocusRequester() }
     var exitReady by remember { mutableStateOf(false) }
     var prevTabName by rememberSaveable { mutableStateOf<String?>(null) }
@@ -733,10 +764,18 @@ private fun MainHub(
                 exitConfirm = false
                 homeChromeCompact = false
                 when (it) {
-                    MainTab.Tv, MainTab.TvGuide, MainTab.Events -> {
+                    MainTab.Tv, MainTab.TvGuide -> {
                         navFocused = false
                         onTvFocusContent()
                     }
+                    MainTab.Events -> {
+                        navFocused = false
+                        onTvFocusContent()
+                        hubScope.launch {
+                            delay(120)
+                            runCatching { eventsContentFocus.requestFocus() }
+                        }
+                    }
                     MainTab.Home -> {
                         navFocused = false
                         hubScope.launch {
@@ -763,7 +802,11 @@ private fun MainHub(
                     else -> Unit
                 }
             },
-            contentDownFocus = if (tab == MainTab.Home) homeContentFocus else null,
+            contentDownFocus = when (tab) {
+                MainTab.Home -> homeContentFocus
+                MainTab.Events -> eventsContentFocus
+                else -> null
+            },
             subItems = subItems,
             selectedSubId = selectedSubId,
             focusSelectedToken = topNavFocusToken,
@@ -870,6 +913,12 @@ private fun MainHub(
                 )
                 MainTab.Events -> EventsScreen(
                     api = api,
+                    contentFocusRequester = eventsContentFocus,
+                    navFocusRequester = navFocus,
+                    focusRestoreNonce = eventsReturnNonce,
+                    restoreEventId = restoreEventId,
+                    pendingFocusRestore = pendingEventsFocusRestore,
+                    onFocusRestoreConsumed = onEventsFocusRestoreConsumed,
                     onOpenEvent = onOpenEvent,
                     onPlayEvent = onPlayEvent,
                     onContentFocused = { navFocused = false },
diff --git a/apps/master-api/prisma/migrations/20260919010000_viewer_live_events_access/migration.sql b/apps/master-api/prisma/migrations/20260919010000_viewer_live_events_access/migration.sql
new file mode 100644
index 0000000..02cacf7
--- /dev/null
+++ b/apps/master-api/prisma/migrations/20260919010000_viewer_live_events_access/migration.sql
@@ -0,0 +1,3 @@
+-- Per-user Live Events toggle + optional provider allowlist (JSON text).
+ALTER TABLE "viewer_users" ADD COLUMN IF NOT EXISTS "live_events_enabled" BOOLEAN NOT NULL DEFAULT true;
+ALTER TABLE "viewer_users" ADD COLUMN IF NOT EXISTS "live_events_providers" TEXT;
diff --git a/apps/master-api/prisma/schema.prisma b/apps/master-api/prisma/schema.prisma
index 3f88120..f3174ca 100644
--- a/apps/master-api/prisma/schema.prisma
+++ b/apps/master-api/prisma/schema.prisma
@@ -76,6 +76,13 @@ model ViewerUser {
   appAccess    Boolean  @default(true) @map("app_access")
   /** Live TV in de apps (Xtream-lijn op deze gebruiker). */
   iptvAccess   Boolean  @default(false) @map("iptv_access")
+  /** Live Events-tab in apps (naast cluster-feed + globale provider-toggles). */
+  liveEventsEnabled Boolean @default(true) @map("live_events_enabled")
+  /**
+   * JSON-array van toegestane provider-ids (lowercase).
+   * null/leeg = alle globaal-ingeschakelde providers.
+   */
+  liveEventsProviders String? @map("live_events_providers") @db.Text
   /** @deprecated Legacy: IPTV via addon-token; voorkeur = iptvLine op deze user. */
   iptvAddonTokenId String? @map("iptv_addon_token_id")
   /** Google-account voor Play Closed Testing; fallback = email */
diff --git a/apps/master-api/src/settings/iptv.ts b/apps/master-api/src/settings/iptv.ts
index 7bcec96..23f6b94 100644
--- a/apps/master-api/src/settings/iptv.ts
+++ b/apps/master-api/src/settings/iptv.ts
@@ -11,6 +11,11 @@ export type IptvSettingsPublic = {
   showAlleZenders: boolean;
   /** FAAB (of andere) live-events JSON feed; leeg = default FAAB-URL. */
   liveEventsUrl: string;
+  /**
+   * Providers die cluster-breed uit staan.
+   * Nieuwe providers die hier niet in staan blijven aan (default ON).
+   */
+  liveEventsDisabledProviders: string[];
 };
 
 type StoredJson = Partial<{
@@ -18,6 +23,7 @@ type StoredJson = Partial<{
   categoryOrder: unknown;
   showAlleZenders: unknown;
   liveEventsUrl: unknown;
+  liveEventsDisabledProviders: unknown;
 }>;
 
 type CacheEntry = { at: number; settings: IptvSettingsPublic };
@@ -78,6 +84,22 @@ function normalizeIdList(raw: unknown): string[] {
   return out;
 }
 
+/** Provider-ids: trim + lowercase, uniek, gesorteerd. */
+export function normalizeProviderIdList(raw: unknown): string[] {
+  if (!Array.isArray(raw)) return [];
+  const out: string[] = [];
+  const seen = new Set<string>();
+  for (const item of raw) {
+    const id = String(item ?? "")
+      .trim()
+      .toLowerCase();
+    if (!id || seen.has(id)) continue;
+    seen.add(id);
+    out.push(id);
+  }
+  return out.sort((a, b) => a.localeCompare(b, "nl"));
+}
+
 const DEFAULT_LIVE_EVENTS_URL =
   "http://epg.faabserver.nl/api/export/live-events?horizon_days=3";
 
@@ -100,6 +122,7 @@ function defaultsFromEnv(config: Config): IptvSettingsPublic {
     categoryOrder: [],
     showAlleZenders: true,
     liveEventsUrl: DEFAULT_LIVE_EVENTS_URL,
+    liveEventsDisabledProviders: [],
   };
 }
 
@@ -118,6 +141,9 @@ function fromStored(stored: StoredJson, config: Config): IptvSettingsPublic {
     liveEventsUrl: hasLiveEventsUrl
       ? normalizeSingleUrl(stored.liveEventsUrl, "")
       : base.liveEventsUrl,
+    liveEventsDisabledProviders: normalizeProviderIdList(
+      stored.liveEventsDisabledProviders
+    ),
   };
 }
 
@@ -149,6 +175,7 @@ export async function upsertIptvSettings(
     categoryOrder?: unknown;
     showAlleZenders?: unknown;
     liveEventsUrl?: unknown;
+    liveEventsDisabledProviders?: unknown;
   }
 ): Promise<IptvSettingsPublic> {
   const current = await getIptvSettings(config);
@@ -169,6 +196,10 @@ export async function upsertIptvSettings(
       body.liveEventsUrl !== undefined
         ? normalizeSingleUrl(body.liveEventsUrl, "")
         : current.liveEventsUrl,
+    liveEventsDisabledProviders:
+      body.liveEventsDisabledProviders !== undefined
+        ? normalizeProviderIdList(body.liveEventsDisabledProviders)
+        : current.liveEventsDisabledProviders,
   };
 
   if (body.epgXmlUrls !== undefined) {
diff --git a/apps/master-api/src/settings/routes.ts b/apps/master-api/src/settings/routes.ts
index 79a5113..17a6b25 100644
--- a/apps/master-api/src/settings/routes.ts
+++ b/apps/master-api/src/settings/routes.ts
@@ -87,7 +87,20 @@ export function registerSettingsRoutes(
       getIptvSettings(config),
       listIptvCategoriesForAdmin(config),
     ]);
-    return { settings, categories };
+    let liveEventProviders: string[] = [];
+    try {
+      const { discoverScheduleEventProviders } = await import("../viewer/schedule-events");
+      liveEventProviders = await discoverScheduleEventProviders(config);
+    } catch {
+      liveEventProviders = [];
+    }
+    // Include known-but-disabled providers so admin can re-enable them
+    const known = new Set([
+      ...liveEventProviders,
+      ...settings.liveEventsDisabledProviders,
+    ]);
+    liveEventProviders = [...known].sort((a, b) => a.localeCompare(b, "nl"));
+    return { settings, categories, liveEventProviders };
   });
 
   app.put("/api/v1/admin/settings/iptv", { preHandler: requireAdmin }, async (request) => {
@@ -96,10 +109,23 @@ export function registerSettingsRoutes(
       categoryOrder?: string[];
       showAlleZenders?: boolean;
       liveEventsUrl?: string;
+      liveEventsDisabledProviders?: string[];
     };
     const settings = await upsertIptvSettings(config, body);
     const categories = await listIptvCategoriesForAdmin(config);
-    return { settings, categories };
+    let liveEventProviders: string[] = [];
+    try {
+      const { discoverScheduleEventProviders } = await import("../viewer/schedule-events");
+      liveEventProviders = await discoverScheduleEventProviders(config);
+    } catch {
+      liveEventProviders = [];
+    }
+    const known = new Set([
+      ...liveEventProviders,
+      ...settings.liveEventsDisabledProviders,
+    ]);
+    liveEventProviders = [...known].sort((a, b) => a.localeCompare(b, "nl"));
+    return { settings, categories, liveEventProviders };
   });
 
   app.post("/api/v1/admin/settings/iptv/refresh-epg", { preHandler: requireAdmin }, async () => {
diff --git a/apps/master-api/src/viewer/routes.ts b/apps/master-api/src/viewer/routes.ts
index 3e47296..0f3deb2 100644
--- a/apps/master-api/src/viewer/routes.ts
+++ b/apps/master-api/src/viewer/routes.ts
@@ -93,6 +93,8 @@ export function registerViewerRoutes(
       enabled?: boolean;
       appAccess?: boolean;
       iptvAccess?: boolean;
+      liveEventsEnabled?: boolean;
+      liveEventsProviders?: string[] | null;
       iptvAddonTokenId?: string | null;
       password?: string;
     };
@@ -507,17 +509,17 @@ export function registerViewerRoutes(
   app.get("/api/v1/client/me", async (request) => {
     const auth = await viewers.authFromBearer(request.headers.authorization);
     const { getViewerIptvStatus } = await import("./iptv-client");
-    const { eventsFeedEnabled } = await import("./schedule-events");
-    const [iptv, eventsEnabled] = await Promise.all([
+    const { resolveViewerLiveEventsAccess } = await import("./schedule-events");
+    const [iptv, eventsAccess] = await Promise.all([
       getViewerIptvStatus(auth.viewerId, config),
-      eventsFeedEnabled(config),
+      resolveViewerLiveEventsAccess(auth.viewerId, config),
     ]);
     return {
       viewer: { id: auth.viewerId, email: auth.email, name: auth.name },
       deviceId: auth.deviceId,
       profile: auth.profile,
       iptv: { enabled: iptv.enabled },
-      events: { enabled: eventsEnabled },
+      events: { enabled: eventsAccess.enabled },
     };
   });
 
@@ -848,25 +850,28 @@ export function registerViewerRoutes(
   });
 
   app.get("/api/v1/client/events", async (request) => {
-    await viewers.authFromBearer(request.headers.authorization);
-    const { listScheduleEvents } = await import("./schedule-events");
-    return listScheduleEvents(config);
+    const auth = await viewers.authFromBearer(request.headers.authorization);
+    const { listScheduleEvents, resolveViewerLiveEventsAccess } = await import("./schedule-events");
+    const access = await resolveViewerLiveEventsAccess(auth.viewerId, config);
+    return listScheduleEvents(config, access);
   });
 
   app.get("/api/v1/client/events/:id", async (request) => {
-    await viewers.authFromBearer(request.headers.authorization);
+    const auth = await viewers.authFromBearer(request.headers.authorization);
     const { id } = request.params as { id: string };
     if (!id?.trim()) throw new AppError("INVALID_REQUEST", "Ongeldig event-id", 400);
-    const { getScheduleEvent } = await import("./schedule-events");
-    return { event: await getScheduleEvent(config, decodeURIComponent(id)) };
+    const { getScheduleEvent, resolveViewerLiveEventsAccess } = await import("./schedule-events");
+    const access = await resolveViewerLiveEventsAccess(auth.viewerId, config);
+    return { event: await getScheduleEvent(config, decodeURIComponent(id), access) };
   });
 
   app.get("/api/v1/client/events/:id/play", async (request) => {
-    await viewers.authFromBearer(request.headers.authorization);
+    const auth = await viewers.authFromBearer(request.headers.authorization);
     const { id } = request.params as { id: string };
     if (!id?.trim()) throw new AppError("INVALID_REQUEST", "Ongeldig event-id", 400);
-    const { getScheduleEventPlay } = await import("./schedule-events");
-    return getScheduleEventPlay(config, decodeURIComponent(id));
+    const { getScheduleEventPlay, resolveViewerLiveEventsAccess } = await import("./schedule-events");
+    const access = await resolveViewerLiveEventsAccess(auth.viewerId, config);
+    return getScheduleEventPlay(config, decodeURIComponent(id), access);
   });
 
   app.get("/api/v1/client/subtitles/search", async (request) => {
diff --git a/apps/master-api/src/viewer/schedule-events.ts b/apps/master-api/src/viewer/schedule-events.ts
index 2d2e844..82df1b8 100644
--- a/apps/master-api/src/viewer/schedule-events.ts
+++ b/apps/master-api/src/viewer/schedule-events.ts
@@ -1,6 +1,7 @@
 import type { Config } from "../config";
 import { AppError } from "../security/errors";
-import { getIptvSettings } from "../settings/iptv";
+import { getIptvSettings, normalizeProviderIdList } from "../settings/iptv";
+import { prisma } from "../database/client";
 
 const CACHE_TTL_MS = 60_000;
 const FETCH_TIMEOUT_MS = 20_000;
@@ -32,6 +33,17 @@ export type ScheduleEventPublic = {
   audioLanguages: string[];
 };
 
+/** Viewer + globale provider-filter voor list/detail/play. */
+export type LiveEventsAccessFilter = {
+  /** false → 403 op client-endpoints */
+  enabled: boolean;
+  /**
+   * null/empty = alle globaal-ingeschakelde providers.
+   * Anders: subset (lowercase ids).
+   */
+  allowedProviders: string[] | null;
+};
+
 type RawKid = { kid?: unknown; key?: unknown };
 type RawEvent = {
   id?: unknown;
@@ -116,10 +128,18 @@ function pickImages(raw: RawEvent): string[] {
 function scoreLandscape(url: string): number {
   const u = url.toLowerCase();
   let score = 0;
+  // Ziggo Sport FAAB live thumbs (akamaized …/live/…/thumb.jpg?scale=640x360)
+  if (u.includes("thumb")) score += 55;
+  if (u.includes("akamaized.net/live")) score += 50;
+  if (u.includes("scale=")) score += 35;
+  if (u.includes("640x360") || u.includes("scale=640")) score += 30;
   if (u.includes("_l.") || u.includes("_l?")) score += 50;
   if (u.includes("width=960") && u.includes("height=540")) score += 40;
   if (u.includes("width=1280") || u.includes("height=720")) score += 30;
   if (u.includes(".jpg") || u.includes(".jpeg") || u.includes(".webp")) score += 5;
+  // Channel logo PNGs are not landscape artwork
+  if (u.includes("assets/channels")) score -= 70;
+  if (u.includes("/channels/") && u.includes(".png")) score -= 50;
   if (u.includes("logo")) score -= 40;
   if (u.includes("_c.") || u.includes("_c?")) score -= 20;
   if (u.includes(".png") && u.includes("logo")) score -= 50;
@@ -131,7 +151,8 @@ function scorePortrait(url: string): number {
   let score = 0;
   if (u.includes("_c.") || u.includes("_c?")) score += 50;
   if (u.includes("width=199") || u.includes("height=298")) score += 30;
-  if (u.includes("logo")) score -= 40;
+  if (u.includes("assets/channels") || u.includes("logo")) score -= 40;
+  if (u.includes("thumb") || u.includes("akamaized.net/live")) score -= 20;
   if (u.includes("_l.")) score -= 10;
   return score;
 }
@@ -139,13 +160,89 @@ function scorePortrait(url: string): number {
 function scoreLogo(url: string): number {
   const u = url.toLowerCase();
   let score = 0;
+  if (u.includes("assets/channels")) score += 80;
+  if (u.includes("ziggo_sport")) score += 45;
+  if (u.includes("/channels/") && u.includes(".png")) score += 55;
   if (u.includes("logo")) score += 60;
   if (u.includes(".png")) score += 20;
   if (u.includes("cropped")) score += 10;
+  // Live thumbs are not logos
+  if (u.includes("thumb") || u.includes("akamaized.net/live") || u.includes("scale=")) score -= 50;
   if (u.includes("_l.") || u.includes("_c.")) score -= 30;
   return score;
 }
 
+/** Viaplay labels like "Stream 10" / "Stream 22 (NEW)" — hide from public meta. */
+function isStreamLabel(value: string | null | undefined): boolean {
+  const s = str(value);
+  if (!s) return false;
+  return /^stream\s*\d+/i.test(s);
+}
+
+function cleanChannelLabel(value: string | null | undefined): string | null {
+  const s = str(value);
+  if (!s || isStreamLabel(s)) return null;
+  return s;
+}
+
+function normalizeChannelKey(value: string | null | undefined): string {
+  return str(value).toLowerCase().replace(/\s+/g, " ");
+}
+
+function donorImageScore(e: ScheduleEventPublic): number {
+  let s = 0;
+  if (e.imageLandscape) s += 20;
+  if (e.images.some((u) => /thumb|akamaized\.net\/live|scale=/i.test(u))) s += 30;
+  if (e.logoUrl) s += 5;
+  if (e.images.length) s += Math.min(e.images.length, 5);
+  if (e.provider === "ziggosport") s += 8;
+  if (e.playable) s += 3;
+  return s;
+}
+
+/**
+ * Odido (and others) often publish the same channel without images while
+ * ziggosport/FAAB has thumbs for that channel. Fill gaps by channel/network key.
+ */
+function fillMissingImages(events: ScheduleEventPublic[]): ScheduleEventPublic[] {
+  const donors = new Map<string, ScheduleEventPublic>();
+  for (const e of events) {
+    if (!e.imageLandscape && !e.logoUrl && e.images.length === 0) continue;
+    const keys = [e.channel, e.network]
+      .map(normalizeChannelKey)
+      .filter((k) => k.length > 0);
+    for (const key of keys) {
+      const existing = donors.get(key);
+      if (!existing || donorImageScore(e) > donorImageScore(existing)) {
+        donors.set(key, e);
+      }
+    }
+  }
+
+  return events.map((e) => {
+    if (e.imageLandscape || e.images.length > 0) return e;
+    const keys = [e.channel, e.network]
+      .map(normalizeChannelKey)
+      .filter((k) => k.length > 0);
+    let donor: ScheduleEventPublic | undefined;
+    for (const key of keys) {
+      const hit = donors.get(key);
+      if (hit && hit.id !== e.id) {
+        donor = hit;
+        break;
+      }
+    }
+    if (!donor) return e;
+    return {
+      ...e,
+      imageLandscape: e.imageLandscape || donor.imageLandscape,
+      imagePortrait: e.imagePortrait || donor.imagePortrait,
+      logoUrl: e.logoUrl || donor.logoUrl,
+      images: e.images.length ? e.images : [...donor.images],
+    };
+  });
+}
+
 function bestByScore(urls: string[], scorer: (u: string) => number): string | null {
   let best: string | null = null;
   let bestScore = -Infinity;
@@ -231,6 +328,9 @@ function toPublic(raw: RawEvent, nowMs: number): ScheduleEventPublic | null {
   const isLiveFlag = raw.is_live === true;
   const phase = phaseFor(start, stop, isLiveFlag, nowMs);
 
+  const channel = cleanChannelLabel(str(raw.epg?.channel) || str(meta.zender));
+  const network = cleanChannelLabel(str(raw.epg?.network));
+
   return {
     id,
     name,
@@ -238,12 +338,12 @@ function toPublic(raw: RawEvent, nowMs: number): ScheduleEventPublic | null {
       str(raw.description) ||
       str(raw.epg?.description) ||
       null,
-    provider: str(raw.provider) || "unknown",
+    provider: (str(raw.provider) || "unknown").toLowerCase(),
     category: str(raw.category) || str(raw.epg?.category) || null,
     eventType: str(meta.type) || null,
     subtitle: str(meta["originele titel"]) || str(raw.epg?.subtitle) || null,
-    channel: str(raw.epg?.channel) || str(meta.zender) || null,
-    network: str(raw.epg?.network) || null,
+    channel,
+    network,
     isLive: phase === "live",
     phase,
     playable: isPlayable(raw) && phase === "live",
@@ -274,6 +374,78 @@ export async function eventsFeedEnabled(config: Config): Promise<boolean> {
   return !!settings.liveEventsUrl?.trim();
 }
 
+/** Parse JSON allowlist; null/empty → null (= alle globaal-enabled). */
+export function parseLiveEventsProvidersJson(raw: string | null | undefined): string[] | null {
+  if (!raw?.trim()) return null;
+  try {
+    const parsed = JSON.parse(raw) as unknown;
+    const list = normalizeProviderIdList(parsed);
+    return list.length ? list : null;
+  } catch {
+    return null;
+  }
+}
+
+export function serializeLiveEventsProviders(providers: string[] | null | undefined): string | null {
+  if (providers == null) return null;
+  const list = normalizeProviderIdList(providers);
+  return list.length ? JSON.stringify(list) : null;
+}
+
+export async function resolveViewerLiveEventsAccess(
+  viewerId: string,
+  config: Config
+): Promise<LiveEventsAccessFilter> {
+  const feedOn = await eventsFeedEnabled(config);
+  const viewer = await prisma.viewerUser.findUnique({
+    where: { id: viewerId },
+    select: {
+      enabled: true,
+      appAccess: true,
+      liveEventsEnabled: true,
+      liveEventsProviders: true,
+    },
+  });
+  if (!viewer || !viewer.enabled || !viewer.appAccess || !viewer.liveEventsEnabled || !feedOn) {
+    return { enabled: false, allowedProviders: null };
+  }
+  return {
+    enabled: true,
+    allowedProviders: parseLiveEventsProvidersJson(viewer.liveEventsProviders),
+  };
+}
+
+async function globalDisabledProviders(config: Config): Promise<Set<string>> {
+  const settings = await getIptvSettings(config);
+  return new Set(settings.liveEventsDisabledProviders.map((p) => p.toLowerCase()));
+}
+
+function providerAllowed(
+  provider: string,
+  disabledGlobal: Set<string>,
+  userAllow: string[] | null
+): boolean {
+  const p = provider.trim().toLowerCase() || "unknown";
+  if (disabledGlobal.has(p)) return false;
+  if (!userAllow || userAllow.length === 0) return true;
+  return userAllow.includes(p);
+}
+
+function assertAccessEnabled(access?: LiveEventsAccessFilter | null) {
+  if (access && !access.enabled) {
+    throw new AppError("FORBIDDEN", "Live Events is uitgeschakeld voor dit account", 403);
+  }
+}
+
+function filterByAccess(
+  events: ScheduleEventPublic[],
+  disabledGlobal: Set<string>,
+  access?: LiveEventsAccessFilter | null
+): ScheduleEventPublic[] {
+  const userAllow = access?.allowedProviders ?? null;
+  return events.filter((e) => providerAllowed(e.provider, disabledGlobal, userAllow));
+}
+
 async function loadRawEvents(config: Config): Promise<CacheEntry> {
   const url = await resolveLiveEventsUrl(config);
   if (cache && cache.url === url && Date.now() - cache.at < CACHE_TTL_MS) {
@@ -323,14 +495,36 @@ export function invalidateScheduleEventsCache() {
   cache = null;
 }
 
-export async function listScheduleEvents(config: Config): Promise<{
+/** Distinct providers uit de ruwe feed (incl. ended) — voor admin toggles. */
+export async function discoverScheduleEventProviders(config: Config): Promise<string[]> {
+  try {
+    const raw = await loadRawEvents(config);
+    const seen = new Set<string>();
+    const out: string[] = [];
+    for (const e of raw.events) {
+      const p = (str(e.provider) || "unknown").toLowerCase();
+      if (seen.has(p)) continue;
+      seen.add(p);
+      out.push(p);
+    }
+    return out.sort((a, b) => a.localeCompare(b, "nl"));
+  } catch {
+    return [];
+  }
+}
+
+export async function listScheduleEvents(
+  config: Config,
+  access?: LiveEventsAccessFilter | null
+): Promise<{
   generatedAt: string | null;
   events: ScheduleEventPublic[];
   providers: string[];
 }> {
+  assertAccessEnabled(access);
   const raw = await loadRawEvents(config);
   const nowMs = Date.now();
-  const events = raw.events
+  const mapped = raw.events
     .map((e) => toPublic(e, nowMs))
     .filter((e): e is ScheduleEventPublic => e != null)
     .filter((e) => e.phase !== "ended")
@@ -339,8 +533,10 @@ export async function listScheduleEvents(config: Config): Promise<{
       if (b.phase === "live" && a.phase !== "live") return 1;
       return Date.parse(a.start) - Date.parse(b.start);
     });
+  const disabledGlobal = await globalDisabledProviders(config);
+  const events = filterByAccess(fillMissingImages(mapped), disabledGlobal, access);
 
-  const providers = [...new Set(events.map((e) => e.provider))].sort((a, b) =>
+  const providers = [...new Set(events.map((e) => e.provider.toLowerCase()))].sort((a, b) =>
     a.localeCompare(b, "nl")
   );
 
@@ -353,24 +549,35 @@ export async function listScheduleEvents(config: Config): Promise<{
 
 export async function getScheduleEvent(
   config: Config,
-  eventId: string
+  eventId: string,
+  access?: LiveEventsAccessFilter | null
 ): Promise<ScheduleEventPublic> {
+  assertAccessEnabled(access);
   const id = str(eventId);
-  const listed = await listScheduleEvents(config);
+  const listed = await listScheduleEvents(config, access);
   const hit = listed.events.find((e) => e.id === id);
   if (hit) return hit;
 
-  // Ended events still resolvable for detail (no play)
+  // Ended events still resolvable for detail (no play) if provider allowed
   const raw = await loadRawEvents(config);
   const nowMs = Date.now();
   const found = raw.events.find((e) => str(e.id) === id);
   if (!found) throw new AppError("NOT_FOUND", "Event niet gevonden", 404);
   const pub = toPublic(found, nowMs);
   if (!pub) throw new AppError("NOT_FOUND", "Event niet gevonden", 404);
+  const disabledGlobal = await globalDisabledProviders(config);
+  if (!providerAllowed(pub.provider, disabledGlobal, access?.allowedProviders ?? null)) {
+    throw new AppError("NOT_FOUND", "Event niet gevonden", 404);
+  }
   return pub;
 }
 
-export async function getScheduleEventPlay(config: Config, eventId: string) {
+export async function getScheduleEventPlay(
+  config: Config,
+  eventId: string,
+  access?: LiveEventsAccessFilter | null
+) {
+  assertAccessEnabled(access);
   const id = str(eventId);
   const raw = await loadRawEvents(config);
   const found = raw.events.find((e) => str(e.id) === id);
@@ -379,6 +586,12 @@ export async function getScheduleEventPlay(config: Config, eventId: string) {
   const nowMs = Date.now();
   const pub = toPublic(found, nowMs);
   if (!pub) throw new AppError("NOT_FOUND", "Event niet gevonden", 404);
+
+  const disabledGlobal = await globalDisabledProviders(config);
+  if (!providerAllowed(pub.provider, disabledGlobal, access?.allowedProviders ?? null)) {
+    throw new AppError("NOT_FOUND", "Event niet gevonden", 404);
+  }
+
   if (pub.phase === "ended") {
     throw new AppError("GONE", "Dit event is afgelopen", 410);
   }
diff --git a/apps/master-api/src/viewer/service.ts b/apps/master-api/src/viewer/service.ts
index 3b9a33f..ea449e8 100644
--- a/apps/master-api/src/viewer/service.ts
+++ b/apps/master-api/src/viewer/service.ts
@@ -32,6 +32,11 @@ import {
   invalidateHomeForProfile,
 } from "./home-cache";
 import { compactListImages } from "./image-urls";
+import {
+  parseLiveEventsProvidersJson,
+  serializeLiveEventsProviders,
+} from "./schedule-events";
+import { normalizeProviderIdList } from "../settings/iptv";
 
 const CODE_TTL_MS = 10 * 60 * 1000;
 const CODE_ALPHABET = "ABCDEFGHJKLMNPQRSTUVWXYZ23456789";
@@ -186,6 +191,8 @@ export class ViewerService {
       enabled: v.enabled,
       appAccess: v.appAccess,
       iptvAccess: v.iptvAccess,
+      liveEventsEnabled: v.liveEventsEnabled,
+      liveEventsProviders: parseLiveEventsProvidersJson(v.liveEventsProviders),
       iptvAddonTokenId: v.iptvAddonTokenId,
       liveListIds: v.liveChannelLists.map((r) => r.listId),
       liveLists: v.liveChannelLists.map((r) => ({
@@ -249,6 +256,8 @@ export class ViewerService {
       enabled?: boolean;
       appAccess?: boolean;
       iptvAccess?: boolean;
+      liveEventsEnabled?: boolean;
+      liveEventsProviders?: string[] | null;
       iptvAddonTokenId?: string | null;
       password?: string;
     }
@@ -265,6 +274,8 @@ export class ViewerService {
       enabled?: boolean;
       appAccess?: boolean;
       iptvAccess?: boolean;
+      liveEventsEnabled?: boolean;
+      liveEventsProviders?: string | null;
       iptvAddonTokenId?: string | null;
       passwordHash?: string;
     } = {};
@@ -272,6 +283,15 @@ export class ViewerService {
     if (data.enabled !== undefined) patch.enabled = data.enabled;
     if (data.appAccess !== undefined) patch.appAccess = data.appAccess;
     if (data.iptvAccess !== undefined) patch.iptvAccess = data.iptvAccess;
+    if (data.liveEventsEnabled !== undefined) patch.liveEventsEnabled = data.liveEventsEnabled;
+    if (data.liveEventsProviders !== undefined) {
+      if (data.liveEventsProviders === null) {
+        patch.liveEventsProviders = null;
+      } else {
+        const list = normalizeProviderIdList(data.liveEventsProviders);
+        patch.liveEventsProviders = serializeLiveEventsProviders(list);
+      }
+    }
     if (data.iptvAddonTokenId !== undefined) {
       patch.iptvAddonTokenId = data.iptvAddonTokenId?.trim() || null;
     }
@@ -302,6 +322,8 @@ export class ViewerService {
         enabled: true,
         appAccess: true,
         iptvAccess: true,
+        liveEventsEnabled: true,
+        liveEventsProviders: true,
         iptvAddonTokenId: true,
         createdAt: true,
       },
@@ -315,7 +337,10 @@ export class ViewerService {
     if (Object.keys(patch).length > 0) {
       notifyViewersChanged("viewer.updated", { viewerId: updated.id });
     }
-    return updated;
+    return {
+      ...updated,
+      liveEventsProviders: parseLiveEventsProvidersJson(updated.liveEventsProviders),
+    };
   }
 
   async revokeDevice(deviceId: string) {