From 0b107515e42fb68f4f3197ee6ed3f76fdf76bd1c Mon Sep 17 00:00:00 2001
From: Jos Vooges | STH <jos@sthbv.nl>
Date: Mon, 31 Aug 2026 01:11:43 +0200
Subject: [PATCH] Add viewer accounts, device linking, and Android TV client
 foundation.

---
 apps/admin-ui/src/app/link/page.tsx           | 142 ++++
 apps/admin-ui/src/app/viewers/page.tsx        | 225 ++++++
 apps/admin-ui/src/components/Nav.tsx          |   1 +
 apps/android-tv/.gitignore                    |  12 +
 apps/android-tv/README.md                     |  30 +
 apps/android-tv/app/build.gradle.kts          |  66 ++
 apps/android-tv/app/proguard-rules.pro        |   1 +
 .../app/src/main/AndroidManifest.xml          |  35 +
 .../nl/vonas/mediacluster/tv/MainActivity.kt  |  20 +
 .../java/nl/vonas/mediacluster/tv/McApp.kt    |   5 +
 .../vonas/mediacluster/tv/data/ApiClient.kt   | 278 +++++++
 .../mediacluster/tv/data/SessionStore.kt      |  31 +
 .../java/nl/vonas/mediacluster/tv/ui/McNav.kt | 692 +++++++++++++++++
 .../vonas/mediacluster/tv/ui/theme/Theme.kt   |  24 +
 .../app/src/main/res/drawable/app_banner.xml  |   5 +
 .../src/main/res/drawable/ic_launcher_fg.xml  |  10 +
 .../res/mipmap-anydpi-v26/ic_launcher.xml     |   5 +
 .../app/src/main/res/values/colors.xml        |   4 +
 .../app/src/main/res/values/strings.xml       |   4 +
 .../app/src/main/res/values/themes.xml        |   7 +
 apps/android-tv/build.gradle.kts              |   5 +
 apps/android-tv/gradle.properties             |   9 +
 .../gradle/wrapper/gradle-wrapper.jar         | Bin 0 -> 46175 bytes
 .../gradle/wrapper/gradle-wrapper.properties  |   7 +
 apps/android-tv/gradlew                       | 248 ++++++
 apps/android-tv/gradlew.bat                   |  93 +++
 apps/android-tv/settings.gradle.kts           |  16 +
 .../migration.sql                             | 103 +++
 apps/master-api/prisma/schema.prisma          |  99 +++
 apps/master-api/src/app.ts                    |  90 +++
 apps/master-api/src/config.ts                 |   2 +
 apps/master-api/src/viewer/routes.ts          | 187 +++++
 apps/master-api/src/viewer/service.ts         | 717 ++++++++++++++++++
 33 files changed, 3173 insertions(+)
 create mode 100644 apps/admin-ui/src/app/link/page.tsx
 create mode 100644 apps/admin-ui/src/app/viewers/page.tsx
 create mode 100644 apps/android-tv/.gitignore
 create mode 100644 apps/android-tv/README.md
 create mode 100644 apps/android-tv/app/build.gradle.kts
 create mode 100644 apps/android-tv/app/proguard-rules.pro
 create mode 100644 apps/android-tv/app/src/main/AndroidManifest.xml
 create mode 100644 apps/android-tv/app/src/main/java/nl/vonas/mediacluster/tv/MainActivity.kt
 create mode 100644 apps/android-tv/app/src/main/java/nl/vonas/mediacluster/tv/McApp.kt
 create mode 100644 apps/android-tv/app/src/main/java/nl/vonas/mediacluster/tv/data/ApiClient.kt
 create mode 100644 apps/android-tv/app/src/main/java/nl/vonas/mediacluster/tv/data/SessionStore.kt
 create mode 100644 apps/android-tv/app/src/main/java/nl/vonas/mediacluster/tv/ui/McNav.kt
 create mode 100644 apps/android-tv/app/src/main/java/nl/vonas/mediacluster/tv/ui/theme/Theme.kt
 create mode 100644 apps/android-tv/app/src/main/res/drawable/app_banner.xml
 create mode 100644 apps/android-tv/app/src/main/res/drawable/ic_launcher_fg.xml
 create mode 100644 apps/android-tv/app/src/main/res/mipmap-anydpi-v26/ic_launcher.xml
 create mode 100644 apps/android-tv/app/src/main/res/values/colors.xml
 create mode 100644 apps/android-tv/app/src/main/res/values/strings.xml
 create mode 100644 apps/android-tv/app/src/main/res/values/themes.xml
 create mode 100644 apps/android-tv/build.gradle.kts
 create mode 100644 apps/android-tv/gradle.properties
 create mode 100644 apps/android-tv/gradle/wrapper/gradle-wrapper.jar
 create mode 100644 apps/android-tv/gradle/wrapper/gradle-wrapper.properties
 create mode 100644 apps/android-tv/gradlew
 create mode 100644 apps/android-tv/gradlew.bat
 create mode 100644 apps/android-tv/settings.gradle.kts
 create mode 100644 apps/master-api/prisma/migrations/20260831010000_viewer_client/migration.sql
 create mode 100644 apps/master-api/src/viewer/routes.ts
 create mode 100644 apps/master-api/src/viewer/service.ts

diff --git a/apps/admin-ui/src/app/link/page.tsx b/apps/admin-ui/src/app/link/page.tsx
new file mode 100644
index 0000000..65a59e2
--- /dev/null
+++ b/apps/admin-ui/src/app/link/page.tsx
@@ -0,0 +1,142 @@
+"use client";
+
+import { FormEvent, useEffect, useState } from "react";
+
+export default function LinkDevicePage() {
+  const [email, setEmail] = useState("");
+  const [password, setPassword] = useState("");
+  const [code, setCode] = useState("");
+  const [busy, setBusy] = useState(false);
+  const [err, setErr] = useState<string | null>(null);
+  const [ok, setOk] = useState<string | null>(null);
+
+  useEffect(() => {
+    const q = new URLSearchParams(window.location.search);
+    const c = q.get("code");
+    if (c) setCode(c.toUpperCase());
+  }, []);
+
+  async function onSubmit(e: FormEvent) {
+    e.preventDefault();
+    setBusy(true);
+    setErr(null);
+    setOk(null);
+    try {
+      const res = await fetch("/api/v1/link/claim", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ email, password, code }),
+      });
+      const data = await res.json().catch(() => ({}));
+      if (!res.ok) {
+        setErr(data.error?.message ?? "Koppelen mislukt");
+        return;
+      }
+      setOk(`Apparaat “${data.deviceName ?? "TV"}” is gekoppeld. Je kunt dit venster sluiten.`);
+      setPassword("");
+    } finally {
+      setBusy(false);
+    }
+  }
+
+  return (
+    <main className="link-page">
+      <div className="link-card">
+        <p className="page-kicker">Media Cluster</p>
+        <h1>Apparaat koppelen</h1>
+        <p className="muted">
+          Log in met je kijker-account en voer de code van je TV of telefoon in.
+        </p>
+        <form onSubmit={onSubmit} className="link-form">
+          <label>
+            E-mail
+            <input
+              type="email"
+              autoComplete="username"
+              value={email}
+              onChange={(e) => setEmail(e.target.value)}
+              required
+            />
+          </label>
+          <label>
+            Wachtwoord
+            <input
+              type="password"
+              autoComplete="current-password"
+              value={password}
+              onChange={(e) => setPassword(e.target.value)}
+              required
+            />
+          </label>
+          <label>
+            Code
+            <input
+              type="text"
+              inputMode="text"
+              autoCapitalize="characters"
+              autoComplete="one-time-code"
+              placeholder="ABCD-EFGH"
+              value={code}
+              onChange={(e) => setCode(e.target.value.toUpperCase())}
+              required
+            />
+          </label>
+          {err && <p className="form-error">{err}</p>}
+          {ok && <p className="form-ok">{ok}</p>}
+          <button type="submit" className="btn-primary" disabled={busy}>
+            {busy ? "Bezig…" : "Koppelen"}
+          </button>
+        </form>
+      </div>
+      <style jsx>{`
+        .link-page {
+          min-height: 100vh;
+          display: grid;
+          place-items: center;
+          padding: 2rem 1rem;
+          background:
+            radial-gradient(ellipse 80% 50% at 50% -20%, rgba(56, 120, 255, 0.25), transparent),
+            #04060a;
+        }
+        .link-card {
+          width: min(420px, 100%);
+          background: rgba(12, 16, 24, 0.92);
+          border: 1px solid rgba(255, 255, 255, 0.08);
+          border-radius: 16px;
+          padding: 1.75rem;
+        }
+        h1 {
+          margin: 0.25rem 0 0.5rem;
+          font-size: 1.75rem;
+        }
+        .link-form {
+          display: grid;
+          gap: 0.9rem;
+          margin-top: 1.25rem;
+        }
+        label {
+          display: grid;
+          gap: 0.35rem;
+          font-size: 0.85rem;
+          color: rgba(255, 255, 255, 0.7);
+        }
+        input {
+          padding: 0.7rem 0.8rem;
+          border-radius: 10px;
+          border: 1px solid rgba(255, 255, 255, 0.12);
+          background: #0a0e16;
+          color: #fff;
+          font-size: 1rem;
+        }
+        .form-error {
+          color: #ff8b8b;
+          margin: 0;
+        }
+        .form-ok {
+          color: #8dffb0;
+          margin: 0;
+        }
+      `}</style>
+    </main>
+  );
+}
diff --git a/apps/admin-ui/src/app/viewers/page.tsx b/apps/admin-ui/src/app/viewers/page.tsx
new file mode 100644
index 0000000..dd45a75
--- /dev/null
+++ b/apps/admin-ui/src/app/viewers/page.tsx
@@ -0,0 +1,225 @@
+"use client";
+
+import { FormEvent, useCallback, useEffect, useState } from "react";
+import { Nav, useAuth } from "@/components/Nav";
+
+type Device = {
+  id: string;
+  name: string;
+  platform: string;
+  lastSeenAt: string | null;
+  createdAt: string;
+};
+
+type Viewer = {
+  id: string;
+  email: string;
+  name: string | null;
+  enabled: boolean;
+  appAccess: boolean;
+  createdAt: string;
+  deviceCount: number;
+  devices: Device[];
+};
+
+export default function ViewersPage() {
+  useAuth();
+  const [viewers, setViewers] = useState<Viewer[]>([]);
+  const [email, setEmail] = useState("");
+  const [password, setPassword] = useState("");
+  const [name, setName] = useState("");
+  const [busy, setBusy] = useState(false);
+  const [msg, setMsg] = useState<string | null>(null);
+  const [err, setErr] = useState<string | null>(null);
+
+  const load = useCallback(() => {
+    fetch("/api/v1/admin/viewers", { credentials: "include" })
+      .then((r) => r.json())
+      .then((d) => setViewers(d.viewers ?? []))
+      .catch(() => setErr("Kon kijkers niet laden"));
+  }, []);
+
+  useEffect(() => {
+    load();
+  }, [load]);
+
+  async function createViewer(e: FormEvent) {
+    e.preventDefault();
+    setBusy(true);
+    setMsg(null);
+    setErr(null);
+    try {
+      const res = await fetch("/api/v1/admin/viewers", {
+        method: "POST",
+        credentials: "include",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ email, password, name: name || undefined, appAccess: true }),
+      });
+      const data = await res.json().catch(() => ({}));
+      if (!res.ok) {
+        setErr(data.error?.message ?? "Aanmaken mislukt");
+        return;
+      }
+      setMsg(`Kijker ${data.viewer.email} aangemaakt`);
+      setEmail("");
+      setPassword("");
+      setName("");
+      load();
+    } finally {
+      setBusy(false);
+    }
+  }
+
+  async function toggle(v: Viewer, field: "enabled" | "appAccess") {
+    await fetch(`/api/v1/admin/viewers/${v.id}`, {
+      method: "PATCH",
+      credentials: "include",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ [field]: !v[field] }),
+    });
+    load();
+  }
+
+  async function revokeDevice(deviceId: string) {
+    if (!confirm("Apparaat intrekken?")) return;
+    await fetch(`/api/v1/admin/viewers/devices/${deviceId}/revoke`, {
+      method: "POST",
+      credentials: "include",
+    });
+    load();
+  }
+
+  return (
+    <>
+      <Nav />
+      <main className="page">
+        <header className="page-header">
+          <div>
+            <p className="page-kicker">Mensen</p>
+            <h1>Kijkers</h1>
+            <p className="muted">
+              Accounts voor de Android TV / phone-app. Gebruikers koppelen zelf via{" "}
+              <a href="/link">/link</a> met een code.
+            </p>
+          </div>
+        </header>
+
+        <section className="card-block">
+          <h2>Nieuwe kijker</h2>
+          <form className="form-grid" onSubmit={createViewer}>
+            <label>
+              Naam
+              <input value={name} onChange={(e) => setName(e.target.value)} placeholder="Jos" />
+            </label>
+            <label>
+              E-mail
+              <input
+                type="email"
+                required
+                value={email}
+                onChange={(e) => setEmail(e.target.value)}
+              />
+            </label>
+            <label>
+              Wachtwoord
+              <input
+                type="password"
+                required
+                minLength={8}
+                value={password}
+                onChange={(e) => setPassword(e.target.value)}
+              />
+            </label>
+            <button type="submit" className="btn-primary" disabled={busy}>
+              Aanmaken
+            </button>
+          </form>
+          {msg && <p className="form-ok">{msg}</p>}
+          {err && <p className="form-error">{err}</p>}
+        </section>
+
+        <section className="card-block">
+          <h2>Overzicht</h2>
+          {viewers.length === 0 ? (
+            <p className="muted">Nog geen kijkers.</p>
+          ) : (
+            <div className="viewer-list">
+              {viewers.map((v) => (
+                <article key={v.id} className="viewer-row">
+                  <div>
+                    <strong>{v.name || v.email}</strong>
+                    <div className="muted">{v.email}</div>
+                    <div className="muted">
+                      {v.enabled ? "Actief" : "Uit"} · app {v.appAccess ? "aan" : "uit"} ·{" "}
+                      {v.deviceCount} apparaat(en)
+                    </div>
+                  </div>
+                  <div className="viewer-actions">
+                    <button type="button" onClick={() => toggle(v, "enabled")}>
+                      {v.enabled ? "Uitschakelen" : "Activeren"}
+                    </button>
+                    <button type="button" onClick={() => toggle(v, "appAccess")}>
+                      {v.appAccess ? "App uit" : "App aan"}
+                    </button>
+                  </div>
+                  {v.devices.length > 0 && (
+                    <ul className="device-list">
+                      {v.devices.map((d) => (
+                        <li key={d.id}>
+                          <span>
+                            {d.name} <span className="muted">({d.platform})</span>
+                          </span>
+                          <button type="button" onClick={() => revokeDevice(d.id)}>
+                            Intrekken
+                          </button>
+                        </li>
+                      ))}
+                    </ul>
+                  )}
+                </article>
+              ))}
+            </div>
+          )}
+        </section>
+      </main>
+      <style jsx>{`
+        .viewer-list {
+          display: grid;
+          gap: 1rem;
+        }
+        .viewer-row {
+          border: 1px solid rgba(255, 255, 255, 0.08);
+          border-radius: 12px;
+          padding: 1rem;
+          display: grid;
+          gap: 0.75rem;
+        }
+        .viewer-actions {
+          display: flex;
+          flex-wrap: wrap;
+          gap: 0.5rem;
+        }
+        .device-list {
+          list-style: none;
+          margin: 0;
+          padding: 0;
+          display: grid;
+          gap: 0.4rem;
+        }
+        .device-list li {
+          display: flex;
+          justify-content: space-between;
+          gap: 1rem;
+          align-items: center;
+          font-size: 0.9rem;
+        }
+        .form-ok {
+          color: #8dffb0;
+        }
+        .form-error {
+          color: #ff8b8b;
+        }
+      `}</style>
+    </>
+  );
+}
diff --git a/apps/admin-ui/src/components/Nav.tsx b/apps/admin-ui/src/components/Nav.tsx
index dc7383f..186f2d4 100644
--- a/apps/admin-ui/src/components/Nav.tsx
+++ b/apps/admin-ui/src/components/Nav.tsx
@@ -13,6 +13,7 @@ const desktopLinks = [
   { href: "/downloads", label: "Downloads" },
   { href: "/streams", label: "Streams" },
   { href: "/accounts", label: "Accounts" },
+  { href: "/viewers", label: "Kijkers" },
   { href: "/settings", label: "Instellingen" },
 ];
 
diff --git a/apps/android-tv/.gitignore b/apps/android-tv/.gitignore
new file mode 100644
index 0000000..d6b98db
--- /dev/null
+++ b/apps/android-tv/.gitignore
@@ -0,0 +1,12 @@
+/.gradle/
+/.idea/
+/.kotlin/
+**/build/
+local.properties
+*.iml
+.DS_Store
+captures/
+*.apk
+*.aab
+hs_err_pid*
+replay_pid*
diff --git a/apps/android-tv/README.md b/apps/android-tv/README.md
new file mode 100644
index 0000000..f4f5971
--- /dev/null
+++ b/apps/android-tv/README.md
@@ -0,0 +1,30 @@
+# Media Cluster — Android TV / phone client
+
+Native client for the private Media Cluster (alternative to Stremio).
+
+## Features (v0.1)
+
+- Device linking via short code + `/link` page
+- Home with **Verder kijken** + configurable shelves
+- Detail → ExoPlayer direct play (no transcoding)
+- Progress sync to master
+- Shelf visibility / order per viewer
+
+## Setup
+
+1. Open `apps/android-tv` in Android Studio.
+2. Set `DEFAULT_API_BASE` in `app/build.gradle.kts` if needed (default `https://master.vonas.nl`).
+3. On master, set `CLIENT_LINK_BASE_URL` to your admin UI origin (e.g. `https://admin.vonas.nl`) so the TV shows the right link URL.
+4. Run migration `20260831010000_viewer_client`.
+5. Admin → **Kijkers** → create a viewer account.
+6. Install APK on TV → enter code at `/link`.
+
+## API used
+
+- `POST /api/v1/client/device/code`
+- `GET /api/v1/client/device/poll`
+- `POST /api/v1/link/claim`
+- `GET /api/v1/client/home`
+- `POST /api/v1/client/play`
+- `POST /api/v1/client/progress`
+- `GET|PUT /api/v1/client/shelves/prefs`
diff --git a/apps/android-tv/app/build.gradle.kts b/apps/android-tv/app/build.gradle.kts
new file mode 100644
index 0000000..adc121a
--- /dev/null
+++ b/apps/android-tv/app/build.gradle.kts
@@ -0,0 +1,66 @@
+plugins {
+    id("com.android.application")
+    id("org.jetbrains.kotlin.android")
+    id("org.jetbrains.kotlin.plugin.compose")
+}
+
+android {
+    namespace = "nl.vonas.mediacluster.tv"
+    compileSdk = 35
+
+    defaultConfig {
+        applicationId = "nl.vonas.mediacluster.tv"
+        minSdk = 24
+        targetSdk = 35
+        versionCode = 1
+        versionName = "0.1.0"
+        buildConfigField("String", "DEFAULT_API_BASE", "\"https://master.vonas.nl\"")
+    }
+
+    buildTypes {
+        release {
+            isMinifyEnabled = false
+            proguardFiles(
+                getDefaultProguardFile("proguard-android-optimize.txt"),
+                "proguard-rules.pro"
+            )
+        }
+    }
+
+    compileOptions {
+        sourceCompatibility = JavaVersion.VERSION_17
+        targetCompatibility = JavaVersion.VERSION_17
+    }
+    kotlinOptions {
+        jvmTarget = "17"
+    }
+    buildFeatures {
+        compose = true
+        buildConfig = true
+    }
+}
+
+dependencies {
+    val composeBom = platform("androidx.compose:compose-bom:2024.12.01")
+    implementation(composeBom)
+    implementation("androidx.compose.ui:ui")
+    implementation("androidx.compose.ui:ui-tooling-preview")
+    implementation("androidx.compose.material3:material3")
+    implementation("androidx.activity:activity-compose:1.9.3")
+    implementation("androidx.lifecycle:lifecycle-runtime-ktx:2.8.7")
+    implementation("androidx.lifecycle:lifecycle-viewmodel-compose:2.8.7")
+    implementation("androidx.navigation:navigation-compose:2.8.5")
+    implementation("androidx.tv:tv-foundation:1.0.0-alpha11")
+    implementation("androidx.tv:tv-material:1.0.0")
+
+    implementation("androidx.media3:media3-exoplayer:1.5.1")
+    implementation("androidx.media3:media3-ui:1.5.1")
+    implementation("androidx.media3:media3-datasource-okhttp:1.5.1")
+
+    implementation("com.squareup.okhttp3:okhttp:4.12.0")
+    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-android:1.9.0")
+    implementation("androidx.datastore:datastore-preferences:1.1.1")
+    implementation("io.coil-kt:coil-compose:2.7.0")
+
+    debugImplementation("androidx.compose.ui:ui-tooling")
+}
diff --git a/apps/android-tv/app/proguard-rules.pro b/apps/android-tv/app/proguard-rules.pro
new file mode 100644
index 0000000..fb164d6
--- /dev/null
+++ b/apps/android-tv/app/proguard-rules.pro
@@ -0,0 +1 @@
+# Add project specific ProGuard rules here.
diff --git a/apps/android-tv/app/src/main/AndroidManifest.xml b/apps/android-tv/app/src/main/AndroidManifest.xml
new file mode 100644
index 0000000..0995268
--- /dev/null
+++ b/apps/android-tv/app/src/main/AndroidManifest.xml
@@ -0,0 +1,35 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+
+    <uses-permission android:name="android.permission.INTERNET" />
+
+    <uses-feature
+        android:name="android.software.leanback"
+        android:required="false" />
+    <uses-feature
+        android:name="android.hardware.touchscreen"
+        android:required="false" />
+
+    <application
+        android:name=".McApp"
+        android:allowBackup="true"
+        android:banner="@drawable/app_banner"
+        android:icon="@drawable/ic_launcher_fg"
+        android:label="@string/app_name"
+        android:supportsRtl="true"
+        android:theme="@style/Theme.MediaClusterTv"
+        android:usesCleartextTraffic="false">
+        <activity
+            android:name=".MainActivity"
+            android:exported="true"
+            android:banner="@drawable/app_banner"
+            android:configChanges="keyboard|keyboardHidden|navigation"
+            android:screenOrientation="landscape">
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+                <category android:name="android.intent.category.LAUNCHER" />
+                <category android:name="android.intent.category.LEANBACK_LAUNCHER" />
+            </intent-filter>
+        </activity>
+    </application>
+</manifest>
diff --git a/apps/android-tv/app/src/main/java/nl/vonas/mediacluster/tv/MainActivity.kt b/apps/android-tv/app/src/main/java/nl/vonas/mediacluster/tv/MainActivity.kt
new file mode 100644
index 0000000..05ec6ce
--- /dev/null
+++ b/apps/android-tv/app/src/main/java/nl/vonas/mediacluster/tv/MainActivity.kt
@@ -0,0 +1,20 @@
+package nl.vonas.mediacluster.tv
+
+import android.os.Bundle
+import androidx.activity.ComponentActivity
+import androidx.activity.compose.setContent
+import androidx.activity.enableEdgeToEdge
+import nl.vonas.mediacluster.tv.ui.McNav
+import nl.vonas.mediacluster.tv.ui.theme.MediaClusterTheme
+
+class MainActivity : ComponentActivity() {
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        enableEdgeToEdge()
+        setContent {
+            MediaClusterTheme {
+                McNav()
+            }
+        }
+    }
+}
diff --git a/apps/android-tv/app/src/main/java/nl/vonas/mediacluster/tv/McApp.kt b/apps/android-tv/app/src/main/java/nl/vonas/mediacluster/tv/McApp.kt
new file mode 100644
index 0000000..b6ce835
--- /dev/null
+++ b/apps/android-tv/app/src/main/java/nl/vonas/mediacluster/tv/McApp.kt
@@ -0,0 +1,5 @@
+package nl.vonas.mediacluster.tv
+
+import android.app.Application
+
+class McApp : Application()
diff --git a/apps/android-tv/app/src/main/java/nl/vonas/mediacluster/tv/data/ApiClient.kt b/apps/android-tv/app/src/main/java/nl/vonas/mediacluster/tv/data/ApiClient.kt
new file mode 100644
index 0000000..753286c
--- /dev/null
+++ b/apps/android-tv/app/src/main/java/nl/vonas/mediacluster/tv/data/ApiClient.kt
@@ -0,0 +1,278 @@
+package nl.vonas.mediacluster.tv.data
+
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import okhttp3.MediaType.Companion.toMediaType
+import okhttp3.OkHttpClient
+import okhttp3.Request
+import okhttp3.RequestBody.Companion.toRequestBody
+import org.json.JSONArray
+import org.json.JSONObject
+import java.util.concurrent.TimeUnit
+
+class ApiClient(
+    private var baseUrl: String,
+    private var token: String? = null,
+) {
+    private val http = OkHttpClient.Builder()
+        .connectTimeout(20, TimeUnit.SECONDS)
+        .readTimeout(30, TimeUnit.SECONDS)
+        .build()
+
+    private val jsonMedia = "application/json; charset=utf-8".toMediaType()
+
+    fun configure(baseUrl: String, token: String?) {
+        this.baseUrl = baseUrl.trimEnd('/')
+        this.token = token
+    }
+
+    suspend fun createDeviceCode(deviceName: String): DeviceCodeResponse = withContext(Dispatchers.IO) {
+        val body = JSONObject()
+            .put("deviceName", deviceName)
+            .put("platform", "android_tv")
+            .toString()
+            .toRequestBody(jsonMedia)
+        val req = Request.Builder()
+            .url("$baseUrl/api/v1/client/device/code")
+            .post(body)
+            .build()
+        parseObject(execute(req)) { o ->
+            DeviceCodeResponse(
+                code = o.getString("code"),
+                expiresAt = o.optString("expiresAt"),
+                pollIntervalSeconds = o.optInt("pollIntervalSeconds", 2),
+                linkUrl = o.optString("linkUrl"),
+                qrPayload = o.optString("qrPayload"),
+            )
+        }
+    }
+
+    suspend fun pollDeviceCode(code: String): PollResult = withContext(Dispatchers.IO) {
+        val req = Request.Builder()
+            .url("$baseUrl/api/v1/client/device/poll?code=${java.net.URLEncoder.encode(code, "UTF-8")}")
+            .get()
+            .build()
+        parseObject(execute(req)) { o ->
+            when (o.optString("status")) {
+                "linked" -> PollResult.Linked(
+                    refreshToken = o.getString("refreshToken"),
+                    viewerName = o.optJSONObject("viewer")?.optString("name")
+                        ?: o.optJSONObject("viewer")?.optString("email")
+                        ?: "Kijker",
+                )
+                "expired" -> PollResult.Expired
+                "already_linked" -> PollResult.AlreadyLinked
+                else -> PollResult.Pending
+            }
+        }
+    }
+
+    suspend fun home(): HomePayload = withContext(Dispatchers.IO) {
+        val req = authed("$baseUrl/api/v1/client/home").get().build()
+        parseObject(execute(req)) { o ->
+            HomePayload(
+                continueWatching = o.optJSONArray("continueWatching").toItems(),
+                shelves = o.optJSONArray("shelves").toShelves(),
+            )
+        }
+    }
+
+    suspend fun movie(id: String): JSONObject = withContext(Dispatchers.IO) {
+        val req = authed("$baseUrl/api/v1/client/movies/$id").get().build()
+        JSONObject(execute(req))
+    }
+
+    suspend fun series(id: String): JSONObject = withContext(Dispatchers.IO) {
+        val req = authed("$baseUrl/api/v1/client/series/$id").get().build()
+        JSONObject(execute(req))
+    }
+
+    suspend fun play(mediaFileId: String): PlayResult = withContext(Dispatchers.IO) {
+        val body = JSONObject().put("mediaFileId", mediaFileId).toString().toRequestBody(jsonMedia)
+        val req = authed("$baseUrl/api/v1/client/play").post(body).build()
+        parseObject(execute(req)) { o ->
+            PlayResult(
+                streamUrl = o.getString("streamUrl"),
+                sessionId = o.optString("sessionId"),
+                mediaFileId = o.optString("mediaFileId"),
+            )
+        }
+    }
+
+    suspend fun postProgress(
+        mediaType: String,
+        movieId: String? = null,
+        episodeId: String? = null,
+        seriesId: String? = null,
+        positionMs: Long,
+        durationMs: Long,
+    ) = withContext(Dispatchers.IO) {
+        val o = JSONObject()
+            .put("mediaType", mediaType)
+            .put("positionMs", positionMs)
+            .put("durationMs", durationMs)
+        if (movieId != null) o.put("movieId", movieId)
+        if (episodeId != null) o.put("episodeId", episodeId)
+        if (seriesId != null) o.put("seriesId", seriesId)
+        val req = authed("$baseUrl/api/v1/client/progress")
+            .post(o.toString().toRequestBody(jsonMedia))
+            .build()
+        execute(req)
+        Unit
+    }
+
+    suspend fun getShelfPrefs(): List<ShelfPref> = withContext(Dispatchers.IO) {
+        val req = authed("$baseUrl/api/v1/client/shelves/prefs").get().build()
+        parseObject(execute(req)) { o ->
+            val arr = o.optJSONArray("shelves") ?: JSONArray()
+            buildList {
+                for (i in 0 until arr.length()) {
+                    val s = arr.getJSONObject(i)
+                    add(
+                        ShelfPref(
+                            shelfId = s.getString("shelfId"),
+                            name = s.getString("name"),
+                            visible = s.optBoolean("visible", true),
+                            sortOrder = s.optInt("sortOrder", i),
+                        )
+                    )
+                }
+            }
+        }
+    }
+
+    suspend fun saveShelfPrefs(prefs: List<ShelfPref>) = withContext(Dispatchers.IO) {
+        val arr = JSONArray()
+        prefs.forEachIndexed { index, p ->
+            arr.put(
+                JSONObject()
+                    .put("shelfId", p.shelfId)
+                    .put("visible", p.visible)
+                    .put("sortOrder", p.sortOrder.takeIf { it >= 0 } ?: index)
+            )
+        }
+        val body = JSONObject().put("shelves", arr).toString().toRequestBody(jsonMedia)
+        val req = authed("$baseUrl/api/v1/client/shelves/prefs").put(body).build()
+        execute(req)
+        Unit
+    }
+
+    private fun authed(url: String): Request.Builder {
+        val b = Request.Builder().url(url)
+        val t = token
+        if (!t.isNullOrBlank()) b.header("Authorization", "Bearer $t")
+        return b
+    }
+
+    private fun execute(req: Request): String {
+        http.newCall(req).execute().use { res ->
+            val text = res.body?.string().orEmpty()
+            if (!res.isSuccessful) {
+                val msg = runCatching {
+                    JSONObject(text).optJSONObject("error")?.optString("message")
+                }.getOrNull() ?: "HTTP ${res.code}"
+                throw ApiException(msg)
+            }
+            return text
+        }
+    }
+
+    private fun <T> parseObject(text: String, block: (JSONObject) -> T): T = block(JSONObject(text))
+}
+
+class ApiException(message: String) : Exception(message)
+
+data class DeviceCodeResponse(
+    val code: String,
+    val expiresAt: String,
+    val pollIntervalSeconds: Int,
+    val linkUrl: String,
+    val qrPayload: String,
+)
+
+sealed class PollResult {
+    data object Pending : PollResult()
+    data object Expired : PollResult()
+    data object AlreadyLinked : PollResult()
+    data class Linked(val refreshToken: String, val viewerName: String) : PollResult()
+}
+
+data class HomePayload(
+    val continueWatching: List<MediaItem>,
+    val shelves: List<ShelfRow>,
+)
+
+data class ShelfRow(
+    val id: String,
+    val title: String,
+    val kind: String,
+    val items: List<MediaItem>,
+)
+
+data class MediaItem(
+    val type: String,
+    val id: String,
+    val title: String,
+    val subtitle: String? = null,
+    val year: Int? = null,
+    val posterUrl: String? = null,
+    val backdropUrl: String? = null,
+    val mediaFileId: String? = null,
+    val positionMs: Long = 0,
+    val durationMs: Long = 0,
+    val progressId: String? = null,
+)
+
+data class PlayResult(
+    val streamUrl: String,
+    val sessionId: String,
+    val mediaFileId: String,
+)
+
+data class ShelfPref(
+    val shelfId: String,
+    val name: String,
+    val visible: Boolean,
+    val sortOrder: Int,
+)
+
+private fun JSONArray?.toItems(): List<MediaItem> {
+    if (this == null) return emptyList()
+    return buildList {
+        for (i in 0 until length()) {
+            val o = getJSONObject(i)
+            add(
+                MediaItem(
+                    type = o.optString("type"),
+                    id = o.optString("id"),
+                    title = o.optString("title"),
+                    subtitle = o.optString("subtitle").ifBlank { null },
+                    year = o.optInt("year").takeIf { o.has("year") && !o.isNull("year") },
+                    posterUrl = o.optString("posterUrl").ifBlank { null },
+                    backdropUrl = o.optString("backdropUrl").ifBlank { null },
+                    mediaFileId = o.optString("mediaFileId").ifBlank { null },
+                    positionMs = o.optLong("positionMs"),
+                    durationMs = o.optLong("durationMs"),
+                    progressId = o.optString("progressId").ifBlank { null },
+                )
+            )
+        }
+    }
+}
+
+private fun JSONArray?.toShelves(): List<ShelfRow> {
+    if (this == null) return emptyList()
+    return buildList {
+        for (i in 0 until length()) {
+            val o = getJSONObject(i)
+            add(
+                ShelfRow(
+                    id = o.optString("id"),
+                    title = o.optString("title"),
+                    kind = o.optString("kind"),
+                    items = o.optJSONArray("items").toItems(),
+                )
+            )
+        }
+    }
+}
diff --git a/apps/android-tv/app/src/main/java/nl/vonas/mediacluster/tv/data/SessionStore.kt b/apps/android-tv/app/src/main/java/nl/vonas/mediacluster/tv/data/SessionStore.kt
new file mode 100644
index 0000000..ce64380
--- /dev/null
+++ b/apps/android-tv/app/src/main/java/nl/vonas/mediacluster/tv/data/SessionStore.kt
@@ -0,0 +1,31 @@
+package nl.vonas.mediacluster.tv.data
+
+import android.content.Context
+import androidx.datastore.preferences.core.edit
+import androidx.datastore.preferences.core.stringPreferencesKey
+import androidx.datastore.preferences.preferencesDataStore
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.map
+import nl.vonas.mediacluster.tv.BuildConfig
+
+private val Context.dataStore by preferencesDataStore("mc_tv")
+
+class SessionStore(private val context: Context) {
+    private val tokenKey = stringPreferencesKey("refresh_token")
+    private val apiKey = stringPreferencesKey("api_base")
+
+    val refreshToken: Flow<String?> = context.dataStore.data.map { it[tokenKey] }
+    val apiBase: Flow<String> = context.dataStore.data.map {
+        it[apiKey] ?: BuildConfig.DEFAULT_API_BASE
+    }
+
+    suspend fun setToken(token: String?) {
+        context.dataStore.edit { prefs ->
+            if (token.isNullOrBlank()) prefs.remove(tokenKey) else prefs[tokenKey] = token
+        }
+    }
+
+    suspend fun setApiBase(url: String) {
+        context.dataStore.edit { it[apiKey] = url.trim().trimEnd('/') }
+    }
+}
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
new file mode 100644
index 0000000..c249212
--- /dev/null
+++ b/apps/android-tv/app/src/main/java/nl/vonas/mediacluster/tv/ui/McNav.kt
@@ -0,0 +1,692 @@
+package nl.vonas.mediacluster.tv.ui
+
+import android.os.Build
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.foundation.layout.Row
+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.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.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.collectAsState
+import androidx.compose.runtime.getValue
+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.graphics.Color
+import androidx.compose.ui.layout.ContentScale
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import androidx.compose.ui.viewinterop.AndroidView
+import androidx.media3.common.MediaItem as ExoMediaItem
+import androidx.media3.common.Player
+import androidx.media3.exoplayer.ExoPlayer
+import androidx.media3.ui.PlayerView
+import androidx.navigation.NavType
+import androidx.navigation.compose.NavHost
+import androidx.navigation.compose.composable
+import androidx.navigation.compose.rememberNavController
+import androidx.navigation.navArgument
+import androidx.tv.material3.ClickableSurfaceDefaults
+import androidx.tv.material3.ExperimentalTvMaterial3Api
+import androidx.tv.material3.MaterialTheme
+import androidx.tv.material3.Surface
+import androidx.tv.material3.Text
+import androidx.tv.material3.Switch
+import coil.compose.AsyncImage
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.launch
+import nl.vonas.mediacluster.tv.data.ApiClient
+import nl.vonas.mediacluster.tv.data.ApiException
+import nl.vonas.mediacluster.tv.data.HomePayload
+import nl.vonas.mediacluster.tv.data.MediaItem
+import nl.vonas.mediacluster.tv.data.PollResult
+import nl.vonas.mediacluster.tv.data.SessionStore
+import nl.vonas.mediacluster.tv.data.ShelfPref
+import org.json.JSONObject
+
+@Composable
+fun McNav() {
+    val context = LocalContext.current
+    val store = remember { SessionStore(context) }
+    val api = remember { ApiClient(baseUrl = "") }
+    val nav = rememberNavController()
+    var ready by remember { mutableStateOf(false) }
+    var authed by remember { mutableStateOf(false) }
+
+    LaunchedEffect(Unit) {
+        val base = store.apiBase.first()
+        val token = store.refreshToken.first()
+        api.configure(base, token)
+        authed = !token.isNullOrBlank()
+        ready = true
+    }
+
+    if (!ready) {
+        Box(Modifier.fillMaxSize().background(Color(0xFF04060A)), contentAlignment = Alignment.Center) {
+            Text("Media Cluster", color = Color.White, fontSize = 28.sp)
+        }
+        return
+    }
+
+    NavHost(navController = nav, startDestination = if (authed) "home" else "link") {
+        composable("link") {
+            LinkScreen(
+                api = api,
+                store = store,
+                onLinked = {
+                    authed = true
+                    nav.navigate("home") {
+                        popUpTo("link") { inclusive = true }
+                    }
+                },
+            )
+        }
+        composable("home") {
+            HomeScreen(
+                api = api,
+                onPlayMovie = { id -> nav.navigate("movie/$id") },
+                onPlaySeries = { id -> nav.navigate("series/$id") },
+                onPlayDirect = { mediaFileId, movieId, episodeId, seriesId, type, startMs ->
+                    val m = movieId?.ifBlank { null } ?: "-"
+                    val e = episodeId?.ifBlank { null } ?: "-"
+                    val s = seriesId?.ifBlank { null } ?: "-"
+                    nav.navigate("player/$mediaFileId/$type/$m/$e/$s/$startMs")
+                },
+                onSettings = { nav.navigate("settings") },
+                onLogout = {
+                    kotlinx.coroutines.MainScope().launch {
+                        store.setToken(null)
+                        api.configure(store.apiBase.first(), null)
+                        authed = false
+                        nav.navigate("link") {
+                            popUpTo(0) { inclusive = true }
+                        }
+                    }
+                },
+            )
+        }
+        composable(
+            "movie/{id}",
+            arguments = listOf(navArgument("id") { type = NavType.StringType }),
+        ) { entry ->
+            val id = entry.arguments?.getString("id") ?: return@composable
+            DetailScreen(
+                load = { api.movie(id) },
+                onPlay = { mediaFileId ->
+                    nav.navigate("player/$mediaFileId/MOVIE/$id/-/-/0")
+                },
+                onBack = { nav.popBackStack() },
+            )
+        }
+        composable(
+            "series/{id}",
+            arguments = listOf(navArgument("id") { type = NavType.StringType }),
+        ) { entry ->
+            val id = entry.arguments?.getString("id") ?: return@composable
+            SeriesScreen(
+                load = { api.series(id) },
+                onPlay = { mediaFileId, episodeId ->
+                    nav.navigate("player/$mediaFileId/EPISODE/-/$episodeId/$id/0")
+                },
+                onBack = { nav.popBackStack() },
+            )
+        }
+        composable(
+            "player/{mediaFileId}/{type}/{movieId}/{episodeId}/{seriesId}/{startMs}",
+            arguments = listOf(
+                navArgument("mediaFileId") { type = NavType.StringType },
+                navArgument("type") { type = NavType.StringType },
+                navArgument("movieId") { type = NavType.StringType },
+                navArgument("episodeId") { type = NavType.StringType },
+                navArgument("seriesId") { type = NavType.StringType },
+                navArgument("startMs") { type = NavType.LongType },
+            ),
+        ) { entry ->
+            fun dash(v: String?) = v?.takeIf { it.isNotBlank() && it != "-" }
+            PlayerScreen(
+                api = api,
+                mediaFileId = entry.arguments?.getString("mediaFileId").orEmpty(),
+                mediaType = entry.arguments?.getString("type") ?: "MOVIE",
+                movieId = dash(entry.arguments?.getString("movieId")),
+                episodeId = dash(entry.arguments?.getString("episodeId")),
+                seriesId = dash(entry.arguments?.getString("seriesId")),
+                startMs = entry.arguments?.getLong("startMs") ?: 0L,
+                onBack = { nav.popBackStack() },
+            )
+        }
+        composable("settings") {
+            SettingsScreen(
+                api = api,
+                store = store,
+                onBack = { nav.popBackStack() },
+            )
+        }
+    }
+}
+
+@OptIn(ExperimentalTvMaterial3Api::class)
+@Composable
+private fun LinkScreen(
+    api: ApiClient,
+    store: SessionStore,
+    onLinked: () -> Unit,
+) {
+    val scope = rememberCoroutineScope()
+    var code by remember { mutableStateOf<String?>(null) }
+    var linkUrl by remember { mutableStateOf("") }
+    var error by remember { mutableStateOf<String?>(null) }
+    var status by remember { mutableStateOf("Code ophalen…") }
+
+    LaunchedEffect(Unit) {
+        val base = store.apiBase.first()
+        api.configure(base, null)
+        try {
+            val deviceName = "${Build.MANUFACTURER} ${Build.MODEL}".trim()
+            val created = api.createDeviceCode(deviceName.ifBlank { "Android TV" })
+            code = created.code
+            linkUrl = created.linkUrl
+            status = "Wachten op koppeling…"
+            while (true) {
+                delay((created.pollIntervalSeconds.coerceAtLeast(2)) * 1000L)
+                when (val poll = api.pollDeviceCode(created.code)) {
+                    is PollResult.Linked -> {
+                        store.setToken(poll.refreshToken)
+                        api.configure(base, poll.refreshToken)
+                        status = "Welkom ${poll.viewerName}"
+                        delay(600)
+                        onLinked()
+                        break
+                    }
+                    PollResult.Expired -> {
+                        status = "Code verlopen — herstart de app"
+                        break
+                    }
+                    PollResult.AlreadyLinked -> {
+                        status = "Al gekoppeld — herstart de app"
+                        break
+                    }
+                    PollResult.Pending -> Unit
+                }
+            }
+        } catch (e: Exception) {
+            error = e.message ?: "Kon niet verbinden met master"
+        }
+    }
+
+    Box(
+        Modifier
+            .fillMaxSize()
+            .background(Color(0xFF04060A))
+            .padding(48.dp),
+        contentAlignment = Alignment.Center,
+    ) {
+        Column(horizontalAlignment = Alignment.CenterHorizontally, verticalArrangement = Arrangement.spacedBy(16.dp)) {
+            Text("Media Cluster", fontSize = 40.sp, fontWeight = FontWeight.Bold, color = Color.White)
+            Text("Koppel dit apparaat", fontSize = 22.sp, color = Color(0xFFB8C0D0))
+            Spacer(Modifier.height(12.dp))
+            Text(code ?: "····-····", fontSize = 56.sp, fontWeight = FontWeight.Bold, color = Color(0xFF6EA8FF))
+            if (linkUrl.isNotBlank()) {
+                Text("Ga naar $linkUrl", fontSize = 18.sp, color = Color.White)
+            }
+            Text(status, fontSize = 16.sp, color = Color(0xFF9AA3B5))
+            if (error != null) {
+                Text(error!!, color = Color(0xFFFF8B8B), fontSize = 16.sp)
+            }
+        }
+    }
+}
+
+@OptIn(ExperimentalTvMaterial3Api::class)
+@Composable
+private fun HomeScreen(
+    api: ApiClient,
+    onPlayMovie: (String) -> Unit,
+    onPlaySeries: (String) -> Unit,
+    onPlayDirect: (mediaFileId: String, movieId: String?, episodeId: String?, seriesId: String?, type: String, startMs: Long) -> Unit,
+    onSettings: () -> Unit,
+    onLogout: () -> Unit,
+) {
+    var home by remember { mutableStateOf<HomePayload?>(null) }
+    var error by remember { mutableStateOf<String?>(null) }
+
+    LaunchedEffect(Unit) {
+        try {
+            home = api.home()
+        } catch (e: Exception) {
+            error = e.message
+        }
+    }
+
+    LazyColumn(
+        Modifier
+            .fillMaxSize()
+            .background(Color(0xFF04060A)),
+        contentPadding = PaddingValues(32.dp),
+        verticalArrangement = Arrangement.spacedBy(28.dp),
+    ) {
+        item {
+            Row(
+                Modifier.fillMaxWidth(),
+                horizontalArrangement = Arrangement.SpaceBetween,
+                verticalAlignment = Alignment.CenterVertically,
+            ) {
+                Text("Media Cluster", fontSize = 32.sp, fontWeight = FontWeight.Bold, color = Color.White)
+                Row(horizontalArrangement = Arrangement.spacedBy(12.dp)) {
+                    TvButton("Planken", onSettings)
+                    TvButton("Uitloggen", onLogout)
+                }
+            }
+        }
+        if (error != null) {
+            item { Text(error!!, color = Color(0xFFFF8B8B)) }
+        }
+        val continueItems = home?.continueWatching.orEmpty()
+        if (continueItems.isNotEmpty()) {
+            item {
+                ShelfSection("Verder kijken", continueItems) { item ->
+                    val fileId = item.mediaFileId
+                    if (!fileId.isNullOrBlank()) {
+                        onPlayDirect(
+                            fileId,
+                            item.id.takeIf { item.type == "movie" },
+                            item.id.takeIf { item.type == "episode" },
+                            null,
+                            if (item.type == "episode") "EPISODE" else "MOVIE",
+                            item.positionMs,
+                        )
+                    } else if (item.type == "series" || item.type == "episode") {
+                        // fall through
+                    } else {
+                        onPlayMovie(item.id)
+                    }
+                }
+            }
+        }
+        items(home?.shelves.orEmpty()) { shelf ->
+            ShelfSection(shelf.title, shelf.items) { item ->
+                when (item.type) {
+                    "movie" -> onPlayMovie(item.id)
+                    else -> onPlaySeries(item.id)
+                }
+            }
+        }
+    }
+}
+
+@OptIn(ExperimentalTvMaterial3Api::class)
+@Composable
+private fun ShelfSection(title: String, items: List<MediaItem>, onClick: (MediaItem) -> Unit) {
+    Column(verticalArrangement = Arrangement.spacedBy(12.dp)) {
+        Text(title, fontSize = 22.sp, fontWeight = FontWeight.SemiBold, color = Color.White)
+        LazyRow(horizontalArrangement = Arrangement.spacedBy(14.dp)) {
+            items(items, key = { "${it.type}:${it.id}" }) { item ->
+                PosterCard(item, onClick = { onClick(item) })
+            }
+        }
+    }
+}
+
+@OptIn(ExperimentalTvMaterial3Api::class)
+@Composable
+private fun PosterCard(item: MediaItem, onClick: () -> Unit) {
+    Surface(
+        onClick = onClick,
+        modifier = Modifier.width(140.dp),
+        scale = ClickableSurfaceDefaults.scale(focusedScale = 1.08f),
+        colors = ClickableSurfaceDefaults.colors(
+            containerColor = Color(0xFF121826),
+            focusedContainerColor = Color(0xFF1A2438),
+        ),
+    ) {
+        Column {
+            AsyncImage(
+                model = item.posterUrl,
+                contentDescription = item.title,
+                modifier = Modifier
+                    .fillMaxWidth()
+                    .height(200.dp)
+                    .background(Color(0xFF1A2233)),
+                contentScale = ContentScale.Crop,
+            )
+            Text(
+                item.title,
+                modifier = Modifier.padding(8.dp),
+                color = Color.White,
+                fontSize = 13.sp,
+                maxLines = 2,
+            )
+            if (!item.subtitle.isNullOrBlank()) {
+                Text(
+                    item.subtitle,
+                    modifier = Modifier.padding(horizontal = 8.dp, vertical = 0.dp),
+                    color = Color(0xFF9AA3B5),
+                    fontSize = 11.sp,
+                    maxLines = 1,
+                )
+            }
+            Spacer(Modifier.height(8.dp))
+        }
+    }
+}
+
+@OptIn(ExperimentalTvMaterial3Api::class)
+@Composable
+private fun DetailScreen(
+    load: suspend () -> JSONObject,
+    onPlay: (String) -> Unit,
+    onBack: () -> Unit,
+) {
+    var title by remember { mutableStateOf("…") }
+    var overview by remember { mutableStateOf("") }
+    var backdrop by remember { mutableStateOf<String?>(null) }
+    var files by remember { mutableStateOf<List<Pair<String, String>>>(emptyList()) }
+    var error by remember { mutableStateOf<String?>(null) }
+
+    LaunchedEffect(Unit) {
+        try {
+            val o = load()
+            title = o.optString("title")
+            overview = o.optString("overview")
+            backdrop = o.optString("backdropUrl").ifBlank { null }
+            val arr = o.optJSONArray("mediaFiles")
+            val list = mutableListOf<Pair<String, String>>()
+            if (arr != null) {
+                for (i in 0 until arr.length()) {
+                    val f = arr.getJSONObject(i)
+                    val label = listOfNotNull(
+                        f.optString("resolution").ifBlank { null },
+                        f.optString("hdrType").ifBlank { null },
+                        f.optString("releaseName").ifBlank { null },
+                    ).joinToString(" · ")
+                    list += f.getString("id") to label.ifBlank { "Afspelen" }
+                }
+            }
+            files = list
+        } catch (e: Exception) {
+            error = e.message
+        }
+    }
+
+    Box(Modifier.fillMaxSize().background(Color(0xFF04060A))) {
+        if (backdrop != null) {
+            AsyncImage(
+                model = backdrop,
+                contentDescription = null,
+                modifier = Modifier.fillMaxSize(),
+                contentScale = ContentScale.Crop,
+                alpha = 0.35f,
+            )
+        }
+        Column(Modifier.padding(40.dp), verticalArrangement = Arrangement.spacedBy(16.dp)) {
+            TvButton("Terug", onBack)
+            Text(title, fontSize = 36.sp, fontWeight = FontWeight.Bold, color = Color.White)
+            Text(overview, color = Color(0xFFD0D6E2), fontSize = 16.sp, maxLines = 6)
+            if (error != null) Text(error!!, color = Color(0xFFFF8B8B))
+            LazyRow(horizontalArrangement = Arrangement.spacedBy(12.dp)) {
+                items(files) { (id, label) ->
+                    TvButton(label.take(48), onClick = { onPlay(id) })
+                }
+            }
+        }
+    }
+}
+
+@OptIn(ExperimentalTvMaterial3Api::class)
+@Composable
+private fun SeriesScreen(
+    load: suspend () -> JSONObject,
+    onPlay: (mediaFileId: String, episodeId: String) -> Unit,
+    onBack: () -> Unit,
+) {
+    var title by remember { mutableStateOf("…") }
+    var episodes by remember { mutableStateOf<List<Triple<String, String, String?>>>(emptyList()) }
+    var error by remember { mutableStateOf<String?>(null) }
+
+    LaunchedEffect(Unit) {
+        try {
+            val o = load()
+            title = o.optString("title")
+            val seasons = o.optJSONArray("seasons")
+            val list = mutableListOf<Triple<String, String, String?>>()
+            if (seasons != null) {
+                for (si in 0 until seasons.length()) {
+                    val season = seasons.getJSONObject(si)
+                    val eps = season.optJSONArray("episodes") ?: continue
+                    for (ei in 0 until eps.length()) {
+                        val e = eps.getJSONObject(ei)
+                        if (!e.optBoolean("available", false)) continue
+                        val label = "S${e.optInt("seasonNumber")}E${e.optInt("episodeNumber")} · ${e.optString("title")}"
+                        list += Triple(e.getString("id"), label, e.optString("mediaFileId").ifBlank { null })
+                    }
+                }
+            }
+            episodes = list
+        } catch (e: Exception) {
+            error = e.message
+        }
+    }
+
+    LazyColumn(
+        Modifier.fillMaxSize().background(Color(0xFF04060A)).padding(32.dp),
+        verticalArrangement = Arrangement.spacedBy(10.dp),
+    ) {
+        item {
+            TvButton("Terug", onBack)
+            Spacer(Modifier.height(8.dp))
+            Text(title, fontSize = 32.sp, fontWeight = FontWeight.Bold, color = Color.White)
+            if (error != null) Text(error!!, color = Color(0xFFFF8B8B))
+        }
+        items(episodes) { (id, label, fileId) ->
+            if (fileId != null) {
+                TvButton(label, onClick = { onPlay(fileId, id) })
+            }
+        }
+    }
+}
+
+@Composable
+private fun PlayerScreen(
+    api: ApiClient,
+    mediaFileId: String,
+    mediaType: String,
+    movieId: String?,
+    episodeId: String?,
+    seriesId: String?,
+    startMs: Long,
+    onBack: () -> Unit,
+) {
+    val context = LocalContext.current
+    var error by remember { mutableStateOf<String?>(null) }
+    val player = remember {
+        ExoPlayer.Builder(context).build().apply {
+            playWhenReady = true
+        }
+    }
+
+    LaunchedEffect(mediaFileId) {
+        try {
+            val play = api.play(mediaFileId)
+            player.setMediaItem(ExoMediaItem.fromUri(play.streamUrl))
+            player.prepare()
+            if (startMs > 0) player.seekTo(startMs)
+        } catch (e: Exception) {
+            error = e.message
+        }
+    }
+
+    LaunchedEffect(player) {
+        while (true) {
+            delay(15_000)
+            if (player.playbackState == Player.STATE_READY || player.isPlaying) {
+                try {
+                    api.postProgress(
+                        mediaType = mediaType,
+                        movieId = movieId,
+                        episodeId = episodeId,
+                        seriesId = seriesId,
+                        positionMs = player.currentPosition,
+                        durationMs = player.duration.coerceAtLeast(0),
+                    )
+                } catch (_: ApiException) {
+                }
+            }
+        }
+    }
+
+    androidx.compose.runtime.DisposableEffect(Unit) {
+        onDispose {
+            try {
+                kotlinx.coroutines.runBlocking {
+                    api.postProgress(
+                        mediaType = mediaType,
+                        movieId = movieId,
+                        episodeId = episodeId,
+                        seriesId = seriesId,
+                        positionMs = player.currentPosition,
+                        durationMs = player.duration.coerceAtLeast(0),
+                    )
+                }
+            } catch (_: Exception) {
+            }
+            player.release()
+        }
+    }
+
+    Box(Modifier.fillMaxSize().background(Color.Black)) {
+        AndroidView(
+            factory = { ctx ->
+                PlayerView(ctx).apply {
+                    this.player = player
+                    useController = true
+                }
+            },
+            modifier = Modifier.fillMaxSize(),
+        )
+        if (error != null) {
+            Text(error!!, color = Color(0xFFFF8B8B), modifier = Modifier.align(Alignment.Center))
+        }
+        Box(Modifier.padding(24.dp)) {
+            TvButton("Terug", onBack)
+        }
+    }
+}
+
+@OptIn(ExperimentalTvMaterial3Api::class)
+@Composable
+private fun SettingsScreen(
+    api: ApiClient,
+    store: SessionStore,
+    onBack: () -> Unit,
+) {
+    var prefs by remember { mutableStateOf<List<ShelfPref>>(emptyList()) }
+    var error by remember { mutableStateOf<String?>(null) }
+    val scope = rememberCoroutineScope()
+
+    LaunchedEffect(Unit) {
+        try {
+            prefs = api.getShelfPrefs().sortedBy { it.sortOrder }
+        } catch (e: Exception) {
+            error = e.message
+        }
+    }
+
+    fun persist(next: List<ShelfPref>) {
+        prefs = next
+        scope.launch {
+            try {
+                api.saveShelfPrefs(next.mapIndexed { i, p -> p.copy(sortOrder = i) })
+            } catch (e: Exception) {
+                error = e.message
+            }
+        }
+    }
+
+    LazyColumn(
+        Modifier.fillMaxSize().background(Color(0xFF04060A)).padding(32.dp),
+        verticalArrangement = Arrangement.spacedBy(12.dp),
+    ) {
+        item {
+            TvButton("Terug", onBack)
+            Spacer(Modifier.height(8.dp))
+            Text("Planken", fontSize = 28.sp, fontWeight = FontWeight.Bold, color = Color.White)
+            Text("Zet planken aan/uit en verander de volgorde.", color = Color(0xFF9AA3B5))
+            if (error != null) Text(error!!, color = Color(0xFFFF8B8B))
+        }
+        items(prefs.size) { index ->
+            val p = prefs[index]
+            Row(
+                Modifier.fillMaxWidth().padding(vertical = 4.dp),
+                horizontalArrangement = Arrangement.SpaceBetween,
+                verticalAlignment = Alignment.CenterVertically,
+            ) {
+                Text(p.name, color = Color.White, fontSize = 18.sp, modifier = Modifier.weight(1f))
+                Row(horizontalArrangement = Arrangement.spacedBy(8.dp), verticalAlignment = Alignment.CenterVertically) {
+                    TvButton("Omhoog") {
+                        if (index > 0) {
+                            val next = prefs.toMutableList()
+                            val tmp = next[index - 1]
+                            next[index - 1] = next[index]
+                            next[index] = tmp
+                            persist(next)
+                        }
+                    }
+                    TvButton("Omlaag") {
+                        if (index < prefs.lastIndex) {
+                            val next = prefs.toMutableList()
+                            val tmp = next[index + 1]
+                            next[index + 1] = next[index]
+                            next[index] = tmp
+                            persist(next)
+                        }
+                    }
+                    Switch(
+                        checked = p.visible,
+                        onCheckedChange = { checked ->
+                            val next = prefs.toMutableList()
+                            next[index] = p.copy(visible = checked)
+                            persist(next)
+                        },
+                    )
+                }
+            }
+        }
+    }
+}
+
+@OptIn(ExperimentalTvMaterial3Api::class)
+@Composable
+private fun TvButton(label: String, onClick: () -> Unit) {
+    Surface(
+        onClick = onClick,
+        scale = ClickableSurfaceDefaults.scale(focusedScale = 1.05f),
+        colors = ClickableSurfaceDefaults.colors(
+            containerColor = Color(0xFF1A2438),
+            focusedContainerColor = Color(0xFF2A3A5A),
+        ),
+    ) {
+        Text(
+            label,
+            modifier = Modifier.padding(horizontal = 18.dp, vertical = 10.dp),
+            color = Color.White,
+            fontSize = 15.sp,
+        )
+    }
+}
diff --git a/apps/android-tv/app/src/main/java/nl/vonas/mediacluster/tv/ui/theme/Theme.kt b/apps/android-tv/app/src/main/java/nl/vonas/mediacluster/tv/ui/theme/Theme.kt
new file mode 100644
index 0000000..d396eca
--- /dev/null
+++ b/apps/android-tv/app/src/main/java/nl/vonas/mediacluster/tv/ui/theme/Theme.kt
@@ -0,0 +1,24 @@
+package nl.vonas.mediacluster.tv.ui.theme
+
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.graphics.Color
+import androidx.tv.material3.ExperimentalTvMaterial3Api
+import androidx.tv.material3.MaterialTheme
+import androidx.tv.material3.darkColorScheme
+
+private val Scheme = darkColorScheme(
+    primary = Color(0xFF6EA8FF),
+    onPrimary = Color(0xFF001B3D),
+    surface = Color(0xFF0A0E16),
+    onSurface = Color(0xFFF2F5FA),
+    border = Color(0x33FFFFFF),
+)
+
+@OptIn(ExperimentalTvMaterial3Api::class)
+@Composable
+fun MediaClusterTheme(content: @Composable () -> Unit) {
+    MaterialTheme(
+        colorScheme = Scheme,
+        content = content,
+    )
+}
diff --git a/apps/android-tv/app/src/main/res/drawable/app_banner.xml b/apps/android-tv/app/src/main/res/drawable/app_banner.xml
new file mode 100644
index 0000000..f04c654
--- /dev/null
+++ b/apps/android-tv/app/src/main/res/drawable/app_banner.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<shape xmlns:android="http://schemas.android.com/apk/res/android" android:shape="rectangle">
+    <solid android:color="#0A0E16" />
+    <size android:width="320dp" android:height="180dp" />
+</shape>
diff --git a/apps/android-tv/app/src/main/res/drawable/ic_launcher_fg.xml b/apps/android-tv/app/src/main/res/drawable/ic_launcher_fg.xml
new file mode 100644
index 0000000..961cc1b
--- /dev/null
+++ b/apps/android-tv/app/src/main/res/drawable/ic_launcher_fg.xml
@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="utf-8"?>
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="108dp"
+    android:height="108dp"
+    android:viewportWidth="108"
+    android:viewportHeight="108">
+    <path
+        android:fillColor="#6EA8FF"
+        android:pathData="M30,34h48v8H30zM30,50h48v8H30zM30,66h32v8H30z" />
+</vector>
diff --git a/apps/android-tv/app/src/main/res/mipmap-anydpi-v26/ic_launcher.xml b/apps/android-tv/app/src/main/res/mipmap-anydpi-v26/ic_launcher.xml
new file mode 100644
index 0000000..b420871
--- /dev/null
+++ b/apps/android-tv/app/src/main/res/mipmap-anydpi-v26/ic_launcher.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
+    <background android:drawable="@color/ic_launcher_bg" />
+    <foreground android:drawable="@drawable/ic_launcher_fg" />
+</adaptive-icon>
diff --git a/apps/android-tv/app/src/main/res/values/colors.xml b/apps/android-tv/app/src/main/res/values/colors.xml
new file mode 100644
index 0000000..8ec5f71
--- /dev/null
+++ b/apps/android-tv/app/src/main/res/values/colors.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <color name="ic_launcher_bg">#0A0E16</color>
+</resources>
diff --git a/apps/android-tv/app/src/main/res/values/strings.xml b/apps/android-tv/app/src/main/res/values/strings.xml
new file mode 100644
index 0000000..361b629
--- /dev/null
+++ b/apps/android-tv/app/src/main/res/values/strings.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string name="app_name">Media Cluster</string>
+</resources>
diff --git a/apps/android-tv/app/src/main/res/values/themes.xml b/apps/android-tv/app/src/main/res/values/themes.xml
new file mode 100644
index 0000000..376d16b
--- /dev/null
+++ b/apps/android-tv/app/src/main/res/values/themes.xml
@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <style name="Theme.MediaClusterTv" parent="android:Theme.Material.NoActionBar">
+        <item name="android:windowBackground">#04060A</item>
+        <item name="android:colorPrimary">#6EA8FF</item>
+    </style>
+</resources>
diff --git a/apps/android-tv/build.gradle.kts b/apps/android-tv/build.gradle.kts
new file mode 100644
index 0000000..b9658bf
--- /dev/null
+++ b/apps/android-tv/build.gradle.kts
@@ -0,0 +1,5 @@
+plugins {
+    id("com.android.application") version "8.13.2" apply false
+    id("org.jetbrains.kotlin.android") version "2.0.21" apply false
+    id("org.jetbrains.kotlin.plugin.compose") version "2.0.21" apply false
+}
diff --git a/apps/android-tv/gradle.properties b/apps/android-tv/gradle.properties
new file mode 100644
index 0000000..be48b32
--- /dev/null
+++ b/apps/android-tv/gradle.properties
@@ -0,0 +1,9 @@
+# Lichter voor ~16GB RAM + Android Studio open
+org.gradle.jvmargs=-Xmx1536m -XX:MaxMetaspaceSize=512m -Dfile.encoding=UTF-8
+org.gradle.parallel=false
+org.gradle.workers.max=2
+org.gradle.caching=true
+android.useAndroidX=true
+kotlin.code.style=official
+android.nonTransitiveRClass=true
+kotlin.daemon.jvmargs=-Xmx1024m
diff --git a/apps/android-tv/gradle/wrapper/gradle-wrapper.jar b/apps/android-tv/gradle/wrapper/gradle-wrapper.jar
new file mode 100644
index 0000000000000000000000000000000000000000..61285a659d17295f1de7c53e24fdf13ad755c379
GIT binary patch
literal 46175
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

literal 0
HcmV?d00001

diff --git a/apps/android-tv/gradle/wrapper/gradle-wrapper.properties b/apps/android-tv/gradle/wrapper/gradle-wrapper.properties
new file mode 100644
index 0000000..19a6bde
--- /dev/null
+++ b/apps/android-tv/gradle/wrapper/gradle-wrapper.properties
@@ -0,0 +1,7 @@
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-9.3.0-bin.zip
+networkTimeout=10000
+validateDistributionUrl=true
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists
diff --git a/apps/android-tv/gradlew b/apps/android-tv/gradlew
new file mode 100644
index 0000000..adff685
--- /dev/null
+++ b/apps/android-tv/gradlew
@@ -0,0 +1,248 @@
+#!/bin/sh
+
+#
+# Copyright © 2015 the original authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+
+##############################################################################
+#
+#   Gradle start up script for POSIX generated by Gradle.
+#
+#   Important for running:
+#
+#   (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is
+#       noncompliant, but you have some other compliant shell such as ksh or
+#       bash, then to run this script, type that shell name before the whole
+#       command line, like:
+#
+#           ksh Gradle
+#
+#       Busybox and similar reduced shells will NOT work, because this script
+#       requires all of these POSIX shell features:
+#         * functions;
+#         * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,
+#           «${var#prefix}», «${var%suffix}», and «$( cmd )»;
+#         * compound commands having a testable exit status, especially «case»;
+#         * various built-in commands including «command», «set», and «ulimit».
+#
+#   Important for patching:
+#
+#   (2) This script targets any POSIX shell, so it avoids extensions provided
+#       by Bash, Ksh, etc; in particular arrays are avoided.
+#
+#       The "traditional" practice of packing multiple parameters into a
+#       space-separated string is a well documented source of bugs and security
+#       problems, so this is (mostly) avoided, by progressively accumulating
+#       options in "$@", and eventually passing that to Java.
+#
+#       Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS,
+#       and GRADLE_OPTS) rely on word-splitting, this is performed explicitly;
+#       see the in-line comments for details.
+#
+#       There are tweaks for specific operating systems such as AIX, CygWin,
+#       Darwin, MinGW, and NonStop.
+#
+#   (3) This script is generated from the Groovy template
+#       https://github.com/gradle/gradle/blob/HEAD/platforms/jvm/plugins-application/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
+#       within the Gradle project.
+#
+#       You can find Gradle at https://github.com/gradle/gradle/.
+#
+##############################################################################
+
+# Attempt to set APP_HOME
+
+# Resolve links: $0 may be a link
+app_path=$0
+
+# Need this for daisy-chained symlinks.
+while
+    APP_HOME=${app_path%"${app_path##*/}"}  # leaves a trailing /; empty if no leading path
+    [ -h "$app_path" ]
+do
+    ls=$( ls -ld "$app_path" )
+    link=${ls#*' -> '}
+    case $link in             #(
+      /*)   app_path=$link ;; #(
+      *)    app_path=$APP_HOME$link ;;
+    esac
+done
+
+# This is normally unused
+# shellcheck disable=SC2034
+APP_BASE_NAME=${0##*/}
+# Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036)
+APP_HOME=$( cd -P "${APP_HOME:-./}" > /dev/null && printf '%s\n' "$PWD" ) || exit
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD=maximum
+
+warn () {
+    echo "$*"
+} >&2
+
+die () {
+    echo
+    echo "$*"
+    echo
+    exit 1
+} >&2
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+nonstop=false
+case "$( uname )" in                #(
+  CYGWIN* )         cygwin=true  ;; #(
+  Darwin* )         darwin=true  ;; #(
+  MSYS* | MINGW* )  msys=true    ;; #(
+  NONSTOP* )        nonstop=true ;;
+esac
+
+
+
+# Determine the Java command to use to start the JVM.
+if [ -n "$JAVA_HOME" ] ; then
+    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+        # IBM's JDK on AIX uses strange locations for the executables
+        JAVACMD=$JAVA_HOME/jre/sh/java
+    else
+        JAVACMD=$JAVA_HOME/bin/java
+    fi
+    if [ ! -x "$JAVACMD" ] ; then
+        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+else
+    JAVACMD=java
+    if ! command -v java >/dev/null 2>&1
+    then
+        die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+fi
+
+# Increase the maximum file descriptors if we can.
+if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
+    case $MAX_FD in #(
+      max*)
+        # In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked.
+        # shellcheck disable=SC2039,SC3045
+        MAX_FD=$( ulimit -H -n ) ||
+            warn "Could not query maximum file descriptor limit"
+    esac
+    case $MAX_FD in  #(
+      '' | soft) :;; #(
+      *)
+        # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked.
+        # shellcheck disable=SC2039,SC3045
+        ulimit -n "$MAX_FD" ||
+            warn "Could not set maximum file descriptor limit to $MAX_FD"
+    esac
+fi
+
+# Collect all arguments for the java command, stacking in reverse order:
+#   * args from the command line
+#   * the main class name
+#   * -classpath
+#   * -D...appname settings
+#   * --module-path (only if needed)
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables.
+
+# For Cygwin or MSYS, switch paths to Windows format before running java
+if "$cygwin" || "$msys" ; then
+    APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
+
+    JAVACMD=$( cygpath --unix "$JAVACMD" )
+
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    for arg do
+        if
+            case $arg in                                #(
+              -*)   false ;;                            # don't mess with options #(
+              /?*)  t=${arg#/} t=/${t%%/*}              # looks like a POSIX filepath
+                    [ -e "$t" ] ;;                      #(
+              *)    false ;;
+            esac
+        then
+            arg=$( cygpath --path --ignore --mixed "$arg" )
+        fi
+        # Roll the args list around exactly as many times as the number of
+        # args, so each arg winds up back in the position where it started, but
+        # possibly modified.
+        #
+        # NB: a `for` loop captures its iteration list before it begins, so
+        # changing the positional parameters here affects neither the number of
+        # iterations, nor the values presented in `arg`.
+        shift                   # remove old arg
+        set -- "$@" "$arg"      # push replacement arg
+    done
+fi
+
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+
+# Collect all arguments for the java command:
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments,
+#     and any embedded shellness will be escaped.
+#   * For example: A user cannot expect ${Hostname} to be expanded, as it is an environment variable and will be
+#     treated as '${Hostname}' itself on the command line.
+
+set -- \
+        "-Dorg.gradle.appname=$APP_BASE_NAME" \
+        -jar "$APP_HOME/gradle/wrapper/gradle-wrapper.jar" \
+        "$@"
+
+# Stop when "xargs" is not available.
+if ! command -v xargs >/dev/null 2>&1
+then
+    die "xargs is not available"
+fi
+
+# Use "xargs" to parse quoted args.
+#
+# With -n1 it outputs one arg per line, with the quotes and backslashes removed.
+#
+# In Bash we could simply go:
+#
+#   readarray ARGS < <( xargs -n1 <<<"$var" ) &&
+#   set -- "${ARGS[@]}" "$@"
+#
+# but POSIX shell has neither arrays nor command substitution, so instead we
+# post-process each arg (as a line of input to sed) to backslash-escape any
+# character that might be a shell metacharacter, then use eval to reverse
+# that process (while maintaining the separation between arguments), and wrap
+# the whole thing up as a single "set" statement.
+#
+# This will of course break if any of these variables contains a newline or
+# an unmatched quote.
+#
+
+eval "set -- $(
+        printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" |
+        xargs -n1 |
+        sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' |
+        tr '\n' ' '
+    )" '"$@"'
+
+exec "$JAVACMD" "$@"
diff --git a/apps/android-tv/gradlew.bat b/apps/android-tv/gradlew.bat
new file mode 100644
index 0000000..c4bdd3a
--- /dev/null
+++ b/apps/android-tv/gradlew.bat
@@ -0,0 +1,93 @@
+@rem
+@rem Copyright 2015 the original author or authors.
+@rem
+@rem Licensed under the Apache License, Version 2.0 (the "License");
+@rem you may not use this file except in compliance with the License.
+@rem You may obtain a copy of the License at
+@rem
+@rem      https://www.apache.org/licenses/LICENSE-2.0
+@rem
+@rem Unless required by applicable law or agreed to in writing, software
+@rem distributed under the License is distributed on an "AS IS" BASIS,
+@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+@rem See the License for the specific language governing permissions and
+@rem limitations under the License.
+@rem
+@rem SPDX-License-Identifier: Apache-2.0
+@rem
+
+@if "%DEBUG%"=="" @echo off
+@rem ##########################################################################
+@rem
+@rem  Gradle startup script for Windows
+@rem
+@rem ##########################################################################
+
+@rem Set local scope for the variables with windows NT shell
+if "%OS%"=="Windows_NT" setlocal
+
+set DIRNAME=%~dp0
+if "%DIRNAME%"=="" set DIRNAME=.
+@rem This is normally unused
+set APP_BASE_NAME=%~n0
+set APP_HOME=%DIRNAME%
+
+@rem Resolve any "." and ".." in APP_HOME to make it shorter.
+for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
+
+@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
+
+@rem Find java.exe
+if defined JAVA_HOME goto findJavaFromJavaHome
+
+set JAVA_EXE=java.exe
+%JAVA_EXE% -version >NUL 2>&1
+if %ERRORLEVEL% equ 0 goto execute
+
+echo. 1>&2
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. 1>&2
+echo. 1>&2
+echo Please set the JAVA_HOME variable in your environment to match the 1>&2
+echo location of your Java installation. 1>&2
+
+goto fail
+
+:findJavaFromJavaHome
+set JAVA_HOME=%JAVA_HOME:"=%
+set JAVA_EXE=%JAVA_HOME%/bin/java.exe
+
+if exist "%JAVA_EXE%" goto execute
+
+echo. 1>&2
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% 1>&2
+echo. 1>&2
+echo Please set the JAVA_HOME variable in your environment to match the 1>&2
+echo location of your Java installation. 1>&2
+
+goto fail
+
+:execute
+@rem Setup the command line
+
+
+
+@rem Execute Gradle
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -jar "%APP_HOME%\gradle\wrapper\gradle-wrapper.jar" %*
+
+:end
+@rem End local scope for the variables with windows NT shell
+if %ERRORLEVEL% equ 0 goto mainEnd
+
+:fail
+rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
+rem the _cmd.exe /c_ return code!
+set EXIT_CODE=%ERRORLEVEL%
+if %EXIT_CODE% equ 0 set EXIT_CODE=1
+if not ""=="%GRADLE_EXIT_CONSOLE%" exit %EXIT_CODE%
+exit /b %EXIT_CODE%
+
+:mainEnd
+if "%OS%"=="Windows_NT" endlocal
+
+:omega
diff --git a/apps/android-tv/settings.gradle.kts b/apps/android-tv/settings.gradle.kts
new file mode 100644
index 0000000..547b1f4
--- /dev/null
+++ b/apps/android-tv/settings.gradle.kts
@@ -0,0 +1,16 @@
+pluginManagement {
+    repositories {
+        google()
+        mavenCentral()
+        gradlePluginPortal()
+    }
+}
+dependencyResolutionManagement {
+    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
+    repositories {
+        google()
+        mavenCentral()
+    }
+}
+rootProject.name = "MediaClusterTv"
+include(":app")
diff --git a/apps/master-api/prisma/migrations/20260831010000_viewer_client/migration.sql b/apps/master-api/prisma/migrations/20260831010000_viewer_client/migration.sql
new file mode 100644
index 0000000..bfb44d4
--- /dev/null
+++ b/apps/master-api/prisma/migrations/20260831010000_viewer_client/migration.sql
@@ -0,0 +1,103 @@
+-- Viewer accounts, device linking, watch progress, shelf prefs
+CREATE TYPE "WatchMediaType" AS ENUM ('MOVIE', 'EPISODE');
+
+CREATE TABLE IF NOT EXISTS "viewer_users" (
+  "id" TEXT NOT NULL,
+  "email" TEXT NOT NULL,
+  "password_hash" TEXT NOT NULL,
+  "name" TEXT,
+  "enabled" BOOLEAN NOT NULL DEFAULT true,
+  "app_access" BOOLEAN NOT NULL DEFAULT true,
+  "created_at" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  "updated_at" TIMESTAMP(3) NOT NULL,
+  CONSTRAINT "viewer_users_pkey" PRIMARY KEY ("id")
+);
+
+CREATE UNIQUE INDEX IF NOT EXISTS "viewer_users_email_key" ON "viewer_users"("email");
+
+CREATE TABLE IF NOT EXISTS "viewer_devices" (
+  "id" TEXT NOT NULL,
+  "viewer_user_id" TEXT NOT NULL,
+  "name" TEXT NOT NULL,
+  "platform" TEXT NOT NULL DEFAULT 'android_tv',
+  "refresh_token_hash" TEXT NOT NULL,
+  "last_seen_at" TIMESTAMP(3),
+  "revoked" BOOLEAN NOT NULL DEFAULT false,
+  "created_at" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  "updated_at" TIMESTAMP(3) NOT NULL,
+  CONSTRAINT "viewer_devices_pkey" PRIMARY KEY ("id")
+);
+
+CREATE UNIQUE INDEX IF NOT EXISTS "viewer_devices_refresh_token_hash_key" ON "viewer_devices"("refresh_token_hash");
+CREATE INDEX IF NOT EXISTS "viewer_devices_viewer_user_id_idx" ON "viewer_devices"("viewer_user_id");
+
+CREATE TABLE IF NOT EXISTS "device_link_codes" (
+  "id" TEXT NOT NULL,
+  "code_hash" TEXT NOT NULL,
+  "code_display" TEXT,
+  "device_name" TEXT NOT NULL,
+  "platform" TEXT NOT NULL DEFAULT 'android_tv',
+  "expires_at" TIMESTAMP(3) NOT NULL,
+  "consumed_at" TIMESTAMP(3),
+  "viewer_user_id" TEXT,
+  "claim_token_hash" TEXT,
+  "created_at" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  CONSTRAINT "device_link_codes_pkey" PRIMARY KEY ("id")
+);
+
+CREATE UNIQUE INDEX IF NOT EXISTS "device_link_codes_code_hash_key" ON "device_link_codes"("code_hash");
+CREATE UNIQUE INDEX IF NOT EXISTS "device_link_codes_claim_token_hash_key" ON "device_link_codes"("claim_token_hash");
+CREATE INDEX IF NOT EXISTS "device_link_codes_expires_at_idx" ON "device_link_codes"("expires_at");
+
+CREATE TABLE IF NOT EXISTS "watch_progress" (
+  "id" TEXT NOT NULL,
+  "viewer_user_id" TEXT NOT NULL,
+  "media_type" "WatchMediaType" NOT NULL,
+  "movie_id" TEXT,
+  "episode_id" TEXT,
+  "series_id" TEXT,
+  "position_ms" INTEGER NOT NULL DEFAULT 0,
+  "duration_ms" INTEGER NOT NULL DEFAULT 0,
+  "completed" BOOLEAN NOT NULL DEFAULT false,
+  "hidden_from_continue" BOOLEAN NOT NULL DEFAULT false,
+  "updated_at" TIMESTAMP(3) NOT NULL,
+  "created_at" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  CONSTRAINT "watch_progress_pkey" PRIMARY KEY ("id")
+);
+
+CREATE UNIQUE INDEX IF NOT EXISTS "watch_progress_viewer_user_id_movie_id_key" ON "watch_progress"("viewer_user_id", "movie_id");
+CREATE UNIQUE INDEX IF NOT EXISTS "watch_progress_viewer_user_id_episode_id_key" ON "watch_progress"("viewer_user_id", "episode_id");
+CREATE INDEX IF NOT EXISTS "watch_progress_viewer_user_id_updated_at_idx" ON "watch_progress"("viewer_user_id", "updated_at");
+CREATE INDEX IF NOT EXISTS "watch_progress_viewer_user_id_hidden_from_continue_completed_idx" ON "watch_progress"("viewer_user_id", "hidden_from_continue", "completed");
+
+CREATE TABLE IF NOT EXISTS "viewer_shelf_preferences" (
+  "id" TEXT NOT NULL,
+  "viewer_user_id" TEXT NOT NULL,
+  "shelf_id" TEXT NOT NULL,
+  "visible" BOOLEAN NOT NULL DEFAULT true,
+  "sort_order" INTEGER NOT NULL DEFAULT 0,
+  CONSTRAINT "viewer_shelf_preferences_pkey" PRIMARY KEY ("id")
+);
+
+CREATE UNIQUE INDEX IF NOT EXISTS "viewer_shelf_preferences_viewer_user_id_shelf_id_key" ON "viewer_shelf_preferences"("viewer_user_id", "shelf_id");
+CREATE INDEX IF NOT EXISTS "viewer_shelf_preferences_viewer_user_id_sort_order_idx" ON "viewer_shelf_preferences"("viewer_user_id", "sort_order");
+
+DO $$ BEGIN
+  ALTER TABLE "viewer_devices" ADD CONSTRAINT "viewer_devices_viewer_user_id_fkey"
+    FOREIGN KEY ("viewer_user_id") REFERENCES "viewer_users"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+EXCEPTION WHEN duplicate_object THEN null; END $$;
+
+DO $$ BEGIN
+  ALTER TABLE "device_link_codes" ADD CONSTRAINT "device_link_codes_viewer_user_id_fkey"
+    FOREIGN KEY ("viewer_user_id") REFERENCES "viewer_users"("id") ON DELETE SET NULL ON UPDATE CASCADE;
+EXCEPTION WHEN duplicate_object THEN null; END $$;
+
+DO $$ BEGIN
+  ALTER TABLE "watch_progress" ADD CONSTRAINT "watch_progress_viewer_user_id_fkey"
+    FOREIGN KEY ("viewer_user_id") REFERENCES "viewer_users"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+EXCEPTION WHEN duplicate_object THEN null; END $$;
+
+DO $$ BEGIN
+  ALTER TABLE "viewer_shelf_preferences" ADD CONSTRAINT "viewer_shelf_preferences_viewer_user_id_fkey"
+    FOREIGN KEY ("viewer_user_id") REFERENCES "viewer_users"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+EXCEPTION WHEN duplicate_object THEN null; END $$;
diff --git a/apps/master-api/prisma/schema.prisma b/apps/master-api/prisma/schema.prisma
index 748a7bd..65b3db6 100644
--- a/apps/master-api/prisma/schema.prisma
+++ b/apps/master-api/prisma/schema.prisma
@@ -57,6 +57,105 @@ model User {
   @@map("users")
 }
 
+/** App-kijker (Android TV / phone) — apart van admin User. */
+model ViewerUser {
+  id           String   @id @default(uuid())
+  email        String   @unique
+  passwordHash String   @map("password_hash")
+  name         String?
+  enabled      Boolean  @default(true)
+  appAccess    Boolean  @default(true) @map("app_access")
+  createdAt    DateTime @default(now()) @map("created_at")
+  updatedAt    DateTime @updatedAt @map("updated_at")
+
+  devices    ViewerDevice[]
+  progress   WatchProgress[]
+  shelfPrefs ViewerShelfPreference[]
+  linkCodes  DeviceLinkCode[]
+
+  @@map("viewer_users")
+}
+
+model ViewerDevice {
+  id               String    @id @default(uuid())
+  viewerUserId     String    @map("viewer_user_id")
+  name             String
+  platform         String    @default("android_tv")
+  refreshTokenHash String    @unique @map("refresh_token_hash")
+  lastSeenAt       DateTime? @map("last_seen_at")
+  revoked          Boolean   @default(false)
+  createdAt        DateTime  @default(now()) @map("created_at")
+  updatedAt        DateTime  @updatedAt @map("updated_at")
+
+  viewer ViewerUser @relation(fields: [viewerUserId], references: [id], onDelete: Cascade)
+
+  @@index([viewerUserId])
+  @@map("viewer_devices")
+}
+
+/** Kortstondige koppelcode (TV toont code → gebruiker claimt op /link). */
+model DeviceLinkCode {
+  id           String    @id @default(uuid())
+  codeHash     String    @unique @map("code_hash")
+  /** Display-code (alleen tot claim; daarna null) */
+  codeDisplay  String?   @map("code_display")
+  deviceName   String    @map("device_name")
+  platform     String    @default("android_tv")
+  expiresAt    DateTime  @map("expires_at")
+  consumedAt   DateTime? @map("consumed_at")
+  viewerUserId String?   @map("viewer_user_id")
+  /** Eenmalig token voor device poll na claim */
+  claimTokenHash String? @unique @map("claim_token_hash")
+  createdAt    DateTime  @default(now()) @map("created_at")
+
+  viewer ViewerUser? @relation(fields: [viewerUserId], references: [id], onDelete: SetNull)
+
+  @@index([expiresAt])
+  @@map("device_link_codes")
+}
+
+enum WatchMediaType {
+  MOVIE
+  EPISODE
+}
+
+model WatchProgress {
+  id                   String         @id @default(uuid())
+  viewerUserId         String         @map("viewer_user_id")
+  mediaType            WatchMediaType @map("media_type")
+  movieId              String?        @map("movie_id")
+  episodeId            String?        @map("episode_id")
+  seriesId             String?        @map("series_id")
+  positionMs           Int            @default(0) @map("position_ms")
+  durationMs           Int            @default(0) @map("duration_ms")
+  completed            Boolean        @default(false)
+  hiddenFromContinue   Boolean        @default(false) @map("hidden_from_continue")
+  updatedAt            DateTime       @updatedAt @map("updated_at")
+  createdAt            DateTime       @default(now()) @map("created_at")
+
+  viewer ViewerUser @relation(fields: [viewerUserId], references: [id], onDelete: Cascade)
+
+  @@unique([viewerUserId, movieId])
+  @@unique([viewerUserId, episodeId])
+  @@index([viewerUserId, updatedAt])
+  @@index([viewerUserId, hiddenFromContinue, completed])
+  @@map("watch_progress")
+}
+
+model ViewerShelfPreference {
+  id           String  @id @default(uuid())
+  viewerUserId String  @map("viewer_user_id")
+  shelfId      String  @map("shelf_id")
+  visible      Boolean @default(true)
+  sortOrder    Int     @default(0) @map("sort_order")
+
+  viewer ViewerUser @relation(fields: [viewerUserId], references: [id], onDelete: Cascade)
+
+  @@unique([viewerUserId, shelfId])
+  @@index([viewerUserId, sortOrder])
+  @@map("viewer_shelf_preferences")
+}
+
 model AdminSession {
   id        String   @id @default(uuid())
   userId    String   @map("user_id")
diff --git a/apps/master-api/src/app.ts b/apps/master-api/src/app.ts
index c9d903d..ccdbdc5 100644
--- a/apps/master-api/src/app.ts
+++ b/apps/master-api/src/app.ts
@@ -12,6 +12,7 @@ import { registerAdminRoutes } from "./admin/routes";
 import { registerInstallRoutes } from "./install/routes";
 import { registerDownloadRoutes } from "./downloads/routes";
 import { registerSettingsRoutes } from "./settings/routes";
+import { registerViewerRoutes } from "./viewer/routes";
 import { nodeConnectionManager } from "./websocket/manager";
 import { MetadataService } from "./metadata/service";
 import { toErrorResponse } from "./security/errors";
@@ -75,6 +76,7 @@ async function main() {
   await registerInstallRoutes(app, config);
   registerDownloadRoutes(app, config);
   registerSettingsRoutes(app, config);
+  registerViewerRoutes(app, config);
 
   app.get("/api/v1/node/connect", { websocket: true }, (socket) => {
     void nodeConnectionManager.handleConnection(socket);
@@ -295,6 +297,94 @@ async function main() {
     console.warn("Could not ensure download tables:", err);
   }
 
+  try {
+    await prisma.$executeRawUnsafe(`
+      DO $$ BEGIN
+        CREATE TYPE "WatchMediaType" AS ENUM ('MOVIE', 'EPISODE');
+      EXCEPTION WHEN duplicate_object THEN null; END $$;
+    `);
+    await prisma.$executeRawUnsafe(`
+      CREATE TABLE IF NOT EXISTS "viewer_users" (
+        "id" TEXT NOT NULL,
+        "email" TEXT NOT NULL,
+        "password_hash" TEXT NOT NULL,
+        "name" TEXT,
+        "enabled" BOOLEAN NOT NULL DEFAULT true,
+        "app_access" BOOLEAN NOT NULL DEFAULT true,
+        "created_at" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+        "updated_at" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+        CONSTRAINT "viewer_users_pkey" PRIMARY KEY ("id")
+      )
+    `);
+    await prisma.$executeRawUnsafe(
+      `CREATE UNIQUE INDEX IF NOT EXISTS "viewer_users_email_key" ON "viewer_users"("email")`
+    );
+    await prisma.$executeRawUnsafe(`
+      CREATE TABLE IF NOT EXISTS "viewer_devices" (
+        "id" TEXT NOT NULL,
+        "viewer_user_id" TEXT NOT NULL,
+        "name" TEXT NOT NULL,
+        "platform" TEXT NOT NULL DEFAULT 'android_tv',
+        "refresh_token_hash" TEXT NOT NULL,
+        "last_seen_at" TIMESTAMP(3),
+        "revoked" BOOLEAN NOT NULL DEFAULT false,
+        "created_at" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+        "updated_at" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+        CONSTRAINT "viewer_devices_pkey" PRIMARY KEY ("id")
+      )
+    `);
+    await prisma.$executeRawUnsafe(
+      `CREATE UNIQUE INDEX IF NOT EXISTS "viewer_devices_refresh_token_hash_key" ON "viewer_devices"("refresh_token_hash")`
+    );
+    await prisma.$executeRawUnsafe(`
+      CREATE TABLE IF NOT EXISTS "device_link_codes" (
+        "id" TEXT NOT NULL,
+        "code_hash" TEXT NOT NULL,
+        "code_display" TEXT,
+        "device_name" TEXT NOT NULL,
+        "platform" TEXT NOT NULL DEFAULT 'android_tv',
+        "expires_at" TIMESTAMP(3) NOT NULL,
+        "consumed_at" TIMESTAMP(3),
+        "viewer_user_id" TEXT,
+        "claim_token_hash" TEXT,
+        "created_at" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+        CONSTRAINT "device_link_codes_pkey" PRIMARY KEY ("id")
+      )
+    `);
+    await prisma.$executeRawUnsafe(
+      `CREATE UNIQUE INDEX IF NOT EXISTS "device_link_codes_code_hash_key" ON "device_link_codes"("code_hash")`
+    );
+    await prisma.$executeRawUnsafe(`
+      CREATE TABLE IF NOT EXISTS "watch_progress" (
+        "id" TEXT NOT NULL,
+        "viewer_user_id" TEXT NOT NULL,
+        "media_type" "WatchMediaType" NOT NULL,
+        "movie_id" TEXT,
+        "episode_id" TEXT,
+        "series_id" TEXT,
+        "position_ms" INTEGER NOT NULL DEFAULT 0,
+        "duration_ms" INTEGER NOT NULL DEFAULT 0,
+        "completed" BOOLEAN NOT NULL DEFAULT false,
+        "hidden_from_continue" BOOLEAN NOT NULL DEFAULT false,
+        "updated_at" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+        "created_at" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+        CONSTRAINT "watch_progress_pkey" PRIMARY KEY ("id")
+      )
+    `);
+    await prisma.$executeRawUnsafe(`
+      CREATE TABLE IF NOT EXISTS "viewer_shelf_preferences" (
+        "id" TEXT NOT NULL,
+        "viewer_user_id" TEXT NOT NULL,
+        "shelf_id" TEXT NOT NULL,
+        "visible" BOOLEAN NOT NULL DEFAULT true,
+        "sort_order" INTEGER NOT NULL DEFAULT 0,
+        CONSTRAINT "viewer_shelf_preferences_pkey" PRIMARY KEY ("id")
+      )
+    `);
+  } catch (err) {
+    console.warn("Could not ensure viewer client tables:", err);
+  }
+
   // Repair drifted episode.series_id so series.episodes and seasons.episodes stay aligned.
   try {
     await prisma.$executeRawUnsafe(`
diff --git a/apps/master-api/src/config.ts b/apps/master-api/src/config.ts
index 917b58f..f1b972b 100644
--- a/apps/master-api/src/config.ts
+++ b/apps/master-api/src/config.ts
@@ -11,6 +11,8 @@ const configSchema = z.object({
   ADMIN_PASSWORD: z.string().min(8).optional(),
   TMDB_API_KEY: z.string().optional(),
   PUBLIC_URL: z.string().url().default("http://localhost:3000"),
+  /** Base URL shown on TV for /link (often admin UI). Falls back to PUBLIC_URL. */
+  CLIENT_LINK_BASE_URL: z.string().url().optional(),
   PLAYBACK_IDLE_TIMEOUT_SECONDS: z.coerce.number().default(1200),
   PLAYBACK_ABSOLUTE_LIFETIME_SECONDS: z.coerce.number().default(43200),
   NODE_HEARTBEAT_INTERVAL_SECONDS: z.coerce.number().default(30),
diff --git a/apps/master-api/src/viewer/routes.ts b/apps/master-api/src/viewer/routes.ts
new file mode 100644
index 0000000..bd1a0da
--- /dev/null
+++ b/apps/master-api/src/viewer/routes.ts
@@ -0,0 +1,187 @@
+import type { FastifyInstance } from "fastify";
+import { AppError } from "../security/errors";
+import { requireAdmin } from "../auth/routes";
+import { PlaybackService } from "../playback/service";
+import type { Config } from "../config";
+import { ViewerService } from "./service";
+
+export function registerViewerRoutes(app: FastifyInstance, config: Config) {
+  const playback = new PlaybackService(config);
+  const viewers = new ViewerService(config, playback);
+
+  // ——— Admin: kijkers ———
+  app.get("/api/v1/admin/viewers", { preHandler: requireAdmin }, async () => {
+    return { viewers: await viewers.listViewers() };
+  });
+
+  app.post("/api/v1/admin/viewers", { preHandler: requireAdmin }, async (request) => {
+    const body = request.body as {
+      email?: string;
+      password?: string;
+      name?: string;
+      appAccess?: boolean;
+    };
+    const viewer = await viewers.createViewer({
+      email: body.email || "",
+      password: body.password || "",
+      name: body.name,
+      appAccess: body.appAccess,
+    });
+    return { viewer };
+  });
+
+  app.patch("/api/v1/admin/viewers/:id", { preHandler: requireAdmin }, async (request) => {
+    const { id } = request.params as { id: string };
+    const body = request.body as {
+      name?: string | null;
+      enabled?: boolean;
+      appAccess?: boolean;
+      password?: string;
+    };
+    const viewer = await viewers.updateViewer(id, body);
+    return { viewer };
+  });
+
+  app.post(
+    "/api/v1/admin/viewers/devices/:deviceId/revoke",
+    { preHandler: requireAdmin },
+    async (request) => {
+      const { deviceId } = request.params as { deviceId: string };
+      return viewers.revokeDevice(deviceId);
+    }
+  );
+
+  // ——— Device link (TV) ———
+  app.post(
+    "/api/v1/client/device/code",
+    {
+      config: {
+        rateLimit: { max: 20, timeWindow: "1 minute" },
+      },
+    },
+    async (request) => {
+      const body = (request.body || {}) as { deviceName?: string; platform?: string };
+      return viewers.createDeviceCode(body.deviceName || "Android TV", body.platform || "android_tv");
+    }
+  );
+
+  app.get(
+    "/api/v1/client/device/poll",
+    {
+      config: {
+        rateLimit: { max: 120, timeWindow: "1 minute" },
+      },
+    },
+    async (request) => {
+      const q = request.query as { code?: string };
+      if (!q.code?.trim()) throw new AppError("INVALID_REQUEST", "code verplicht", 400);
+      return viewers.pollDeviceCode(q.code);
+    }
+  );
+
+  // ——— Link page (browser) ———
+  app.post(
+    "/api/v1/link/claim",
+    {
+      config: {
+        rateLimit: { max: 15, timeWindow: "1 minute" },
+      },
+    },
+    async (request) => {
+      const body = request.body as { email?: string; password?: string; code?: string };
+      if (!body.email || !body.password || !body.code) {
+        throw new AppError("INVALID_REQUEST", "E-mail, wachtwoord en code verplicht", 400);
+      }
+      return viewers.claimCode({
+        email: body.email,
+        password: body.password,
+        code: body.code,
+      });
+    }
+  );
+
+  // ——— Authenticated client ———
+  app.get("/api/v1/client/me", async (request) => {
+    const auth = await viewers.authFromBearer(request.headers.authorization);
+    return { viewer: { id: auth.viewerId, email: auth.email, name: auth.name }, deviceId: auth.deviceId };
+  });
+
+  app.get("/api/v1/client/home", async (request) => {
+    const auth = await viewers.authFromBearer(request.headers.authorization);
+    return viewers.home(auth.viewerId);
+  });
+
+  app.get("/api/v1/client/movies/:id", async (request) => {
+    await viewers.authFromBearer(request.headers.authorization);
+    const { id } = request.params as { id: string };
+    return viewers.movieDetail(id);
+  });
+
+  app.get("/api/v1/client/series/:id", async (request) => {
+    await viewers.authFromBearer(request.headers.authorization);
+    const { id } = request.params as { id: string };
+    return viewers.seriesDetail(id);
+  });
+
+  app.post("/api/v1/client/play", async (request) => {
+    const auth = await viewers.authFromBearer(request.headers.authorization);
+    const body = request.body as { mediaFileId?: string };
+    if (!body.mediaFileId) throw new AppError("INVALID_REQUEST", "mediaFileId verplicht", 400);
+    return viewers.play(body.mediaFileId, auth.viewerId);
+  });
+
+  app.post("/api/v1/client/progress", async (request) => {
+    const auth = await viewers.authFromBearer(request.headers.authorization);
+    const body = request.body as {
+      mediaType?: "MOVIE" | "EPISODE";
+      movieId?: string;
+      episodeId?: string;
+      seriesId?: string;
+      positionMs?: number;
+      durationMs?: number;
+      completed?: boolean;
+      hiddenFromContinue?: boolean;
+    };
+    if (!body.mediaType) throw new AppError("INVALID_REQUEST", "mediaType verplicht", 400);
+    const row = await viewers.upsertProgress(auth.viewerId, {
+      mediaType: body.mediaType,
+      movieId: body.movieId,
+      episodeId: body.episodeId,
+      seriesId: body.seriesId,
+      positionMs: body.positionMs ?? 0,
+      durationMs: body.durationMs ?? 0,
+      completed: body.completed,
+      hiddenFromContinue: body.hiddenFromContinue,
+    });
+    return { progress: row };
+  });
+
+  app.post("/api/v1/client/progress/mark-watched", async (request) => {
+    const auth = await viewers.authFromBearer(request.headers.authorization);
+    const body = request.body as { movieId?: string; episodeId?: string };
+    const row = await viewers.markWatched(auth.viewerId, body);
+    return { progress: row };
+  });
+
+  app.post("/api/v1/client/progress/:id/dismiss", async (request) => {
+    const auth = await viewers.authFromBearer(request.headers.authorization);
+    const { id } = request.params as { id: string };
+    return viewers.dismissContinue(auth.viewerId, id);
+  });
+
+  app.get("/api/v1/client/shelves/prefs", async (request) => {
+    const auth = await viewers.authFromBearer(request.headers.authorization);
+    return { shelves: await viewers.getShelfPrefs(auth.viewerId) };
+  });
+
+  app.put("/api/v1/client/shelves/prefs", async (request) => {
+    const auth = await viewers.authFromBearer(request.headers.authorization);
+    const body = request.body as {
+      shelves?: Array<{ shelfId: string; visible: boolean; sortOrder: number }>;
+    };
+    if (!Array.isArray(body.shelves)) {
+      throw new AppError("INVALID_REQUEST", "shelves array verplicht", 400);
+    }
+    return { shelves: await viewers.setShelfPrefs(auth.viewerId, body.shelves) };
+  });
+}
diff --git a/apps/master-api/src/viewer/service.ts b/apps/master-api/src/viewer/service.ts
new file mode 100644
index 0000000..1a2fa17
--- /dev/null
+++ b/apps/master-api/src/viewer/service.ts
@@ -0,0 +1,717 @@
+import { randomBytes } from "crypto";
+import { prisma } from "../database/client";
+import {
+  generateSecureToken,
+  hashPassword,
+  hashToken,
+  verifyPassword,
+} from "../security/crypto";
+import { AppError } from "../security/errors";
+import { PlaybackService } from "../playback/service";
+import type { Config } from "../config";
+import type { FastifyRequest } from "fastify";
+
+const CODE_TTL_MS = 10 * 60 * 1000;
+const CODE_ALPHABET = "ABCDEFGHJKLMNPQRSTUVWXYZ23456789";
+const POLL_INTERVAL_SEC = 2;
+
+export type AuthedViewer = {
+  viewerId: string;
+  deviceId: string;
+  email: string;
+  name: string | null;
+};
+
+export function generateLinkCode(length = 8): string {
+  const bytes = randomBytes(length);
+  let out = "";
+  for (let i = 0; i < length; i++) {
+    out += CODE_ALPHABET[bytes[i]! % CODE_ALPHABET.length];
+  }
+  return `${out.slice(0, 4)}-${out.slice(4)}`;
+}
+
+/** Normalize to ABCD-EFGH then hash — must match createDeviceCode. */
+export function hashLinkCode(raw: string): string {
+  const n = raw.trim().toUpperCase().replace(/[^A-Z0-9]/g, "");
+  const display = n.length === 8 ? `${n.slice(0, 4)}-${n.slice(4)}` : raw.trim().toUpperCase();
+  return hashToken(display);
+}
+
+export class ViewerService {
+  constructor(
+    private readonly config: Config,
+    private readonly playback: PlaybackService
+  ) {}
+
+  async createViewer(input: {
+    email: string;
+    password: string;
+    name?: string | null;
+    appAccess?: boolean;
+  }) {
+    const email = input.email.trim().toLowerCase();
+    if (!email || !input.password || input.password.length < 8) {
+      throw new AppError("INVALID_REQUEST", "E-mail en wachtwoord (min. 8) verplicht", 400);
+    }
+    const existing = await prisma.viewerUser.findUnique({ where: { email } });
+    if (existing) throw new AppError("CONFLICT", "E-mail bestaat al", 409);
+
+    return prisma.viewerUser.create({
+      data: {
+        email,
+        passwordHash: await hashPassword(input.password),
+        name: input.name?.trim() || null,
+        appAccess: input.appAccess !== false,
+      },
+      select: {
+        id: true,
+        email: true,
+        name: true,
+        enabled: true,
+        appAccess: true,
+        createdAt: true,
+      },
+    });
+  }
+
+  async listViewers() {
+    const rows = await prisma.viewerUser.findMany({
+      orderBy: { createdAt: "desc" },
+      include: {
+        _count: { select: { devices: true } },
+        devices: {
+          where: { revoked: false },
+          select: { id: true, name: true, platform: true, lastSeenAt: true, createdAt: true },
+          orderBy: { lastSeenAt: "desc" },
+        },
+      },
+    });
+    return rows.map((v) => ({
+      id: v.id,
+      email: v.email,
+      name: v.name,
+      enabled: v.enabled,
+      appAccess: v.appAccess,
+      createdAt: v.createdAt,
+      deviceCount: v._count.devices,
+      devices: v.devices,
+    }));
+  }
+
+  async updateViewer(
+    id: string,
+    data: {
+      name?: string | null;
+      enabled?: boolean;
+      appAccess?: boolean;
+      password?: string;
+    }
+  ) {
+    const patch: {
+      name?: string | null;
+      enabled?: boolean;
+      appAccess?: boolean;
+      passwordHash?: string;
+    } = {};
+    if (data.name !== undefined) patch.name = data.name?.trim() || null;
+    if (data.enabled !== undefined) patch.enabled = data.enabled;
+    if (data.appAccess !== undefined) patch.appAccess = data.appAccess;
+    if (data.password?.trim()) {
+      if (data.password.length < 8) {
+        throw new AppError("INVALID_REQUEST", "Wachtwoord minstens 8 tekens", 400);
+      }
+      patch.passwordHash = await hashPassword(data.password);
+    }
+    return prisma.viewerUser.update({
+      where: { id },
+      data: patch,
+      select: {
+        id: true,
+        email: true,
+        name: true,
+        enabled: true,
+        appAccess: true,
+        createdAt: true,
+      },
+    });
+  }
+
+  async revokeDevice(deviceId: string) {
+    await prisma.viewerDevice.update({
+      where: { id: deviceId },
+      data: { revoked: true, refreshTokenHash: hashToken(`revoked:${deviceId}:${Date.now()}`) },
+    });
+    return { ok: true };
+  }
+
+  async createDeviceCode(deviceName: string, platform = "android_tv") {
+    const name = deviceName.trim().slice(0, 80) || "Android TV";
+    const code = generateLinkCode(8);
+    const expiresAt = new Date(Date.now() + CODE_TTL_MS);
+    await prisma.deviceLinkCode.create({
+      data: {
+        codeHash: hashLinkCode(code),
+        codeDisplay: code,
+        deviceName: name,
+        platform,
+        expiresAt,
+      },
+    });
+    const linkUrl = `${this.publicBase()}/link`;
+    return {
+      code,
+      expiresAt: expiresAt.toISOString(),
+      expiresInSeconds: Math.floor(CODE_TTL_MS / 1000),
+      pollIntervalSeconds: POLL_INTERVAL_SEC,
+      linkUrl,
+      qrPayload: `${linkUrl}?code=${encodeURIComponent(code)}`,
+    };
+  }
+
+  async pollDeviceCode(codeRaw: string) {
+    const row = await prisma.deviceLinkCode.findUnique({
+      where: { codeHash: hashLinkCode(codeRaw) },
+    });
+    if (!row) throw new AppError("NOT_FOUND", "Onbekende code", 404);
+    if (row.expiresAt.getTime() < Date.now() && !row.consumedAt) {
+      return { status: "expired" as const };
+    }
+    if (!row.consumedAt || !row.viewerUserId) {
+      return { status: "pending" as const };
+    }
+    if (!row.claimTokenHash) {
+      return { status: "already_linked" as const };
+    }
+
+    const refreshToken = generateSecureToken(32);
+    const viewer = await prisma.viewerUser.findUnique({ where: { id: row.viewerUserId } });
+    if (!viewer || !viewer.enabled || !viewer.appAccess) {
+      throw new AppError("FORBIDDEN", "Account heeft geen app-toegang", 403);
+    }
+
+    const device = await prisma.$transaction(async (tx) => {
+      const claimed = await tx.deviceLinkCode.updateMany({
+        where: { id: row.id, claimTokenHash: row.claimTokenHash },
+        data: { claimTokenHash: null, codeDisplay: null },
+      });
+      if (claimed.count === 0) return null;
+      return tx.viewerDevice.create({
+        data: {
+          viewerUserId: viewer.id,
+          name: row.deviceName,
+          platform: row.platform,
+          refreshTokenHash: hashToken(refreshToken),
+          lastSeenAt: new Date(),
+        },
+      });
+    });
+
+    if (!device) return { status: "already_linked" as const };
+
+    return {
+      status: "linked" as const,
+      refreshToken,
+      device: { id: device.id, name: device.name, platform: device.platform },
+      viewer: { id: viewer.id, email: viewer.email, name: viewer.name },
+    };
+  }
+
+  async claimCode(opts: {
+    email: string;
+    password: string;
+    code: string;
+  }) {
+    const email = opts.email.trim().toLowerCase();
+    const viewer = await prisma.viewerUser.findUnique({ where: { email } });
+    if (!viewer || !(await verifyPassword(viewer.passwordHash, opts.password))) {
+      throw new AppError("INVALID_CREDENTIALS", "Ongeldige login", 401);
+    }
+    if (!viewer.enabled || !viewer.appAccess) {
+      throw new AppError("FORBIDDEN", "Geen app-toegang voor dit account", 403);
+    }
+
+    const row = await prisma.deviceLinkCode.findUnique({
+      where: { codeHash: hashLinkCode(opts.code) },
+    });
+    if (!row) throw new AppError("NOT_FOUND", "Onbekende code", 404);
+    if (row.consumedAt) throw new AppError("CONFLICT", "Code al gebruikt", 409);
+    if (row.expiresAt.getTime() < Date.now()) {
+      throw new AppError("EXPIRED", "Code verlopen — start opnieuw op de TV", 410);
+    }
+
+    const claimToken = generateSecureToken(24);
+    await prisma.deviceLinkCode.update({
+      where: { id: row.id },
+      data: {
+        consumedAt: new Date(),
+        viewerUserId: viewer.id,
+        claimTokenHash: hashToken(claimToken),
+      },
+    });
+
+    return {
+      ok: true,
+      deviceName: row.deviceName,
+      viewer: { id: viewer.id, email: viewer.email, name: viewer.name },
+    };
+  }
+
+  async authFromBearer(authHeader?: string): Promise<AuthedViewer> {
+    if (!authHeader?.startsWith("Bearer ")) {
+      throw new AppError("UNAUTHORIZED", "Bearer token verplicht", 401);
+    }
+    const token = authHeader.slice("Bearer ".length).trim();
+    if (!token) throw new AppError("UNAUTHORIZED", "Bearer token verplicht", 401);
+
+    const device = await prisma.viewerDevice.findUnique({
+      where: { refreshTokenHash: hashToken(token) },
+      include: { viewer: true },
+    });
+    if (!device || device.revoked) {
+      throw new AppError("UNAUTHORIZED", "Ongeldig of ingetrokken apparaat", 401);
+    }
+    if (!device.viewer.enabled || !device.viewer.appAccess) {
+      throw new AppError("FORBIDDEN", "Account uitgeschakeld", 403);
+    }
+
+    await prisma.viewerDevice.update({
+      where: { id: device.id },
+      data: { lastSeenAt: new Date() },
+    });
+
+    return {
+      viewerId: device.viewer.id,
+      deviceId: device.id,
+      email: device.viewer.email,
+      name: device.viewer.name,
+    };
+  }
+
+  async home(viewerId: string) {
+    const [shelves, prefs, continueItems] = await Promise.all([
+      prisma.libraryShelf.findMany({
+        where: { enabled: true },
+        orderBy: { sortOrder: "asc" },
+      }),
+      prisma.viewerShelfPreference.findMany({ where: { viewerUserId: viewerId } }),
+      this.continueWatching(viewerId),
+    ]);
+
+    const prefMap = new Map(prefs.map((p) => [p.shelfId, p]));
+    const ordered = shelves
+      .map((s, idx) => {
+        const pref = prefMap.get(s.id);
+        return {
+          id: s.id,
+          name: s.name,
+          slug: s.slug,
+          kind: s.kind,
+          visible: pref?.visible ?? true,
+          sortOrder: pref?.sortOrder ?? s.sortOrder * 10 + idx,
+        };
+      })
+      .filter((s) => s.visible)
+      .sort((a, b) => a.sortOrder - b.sortOrder);
+
+    const rows = [];
+    for (const shelf of ordered) {
+      const items = await this.shelfItems(shelf.id, shelf.kind, 24);
+      if (items.length) {
+        rows.push({
+          id: shelf.id,
+          title: shelf.name,
+          kind: shelf.kind,
+          slug: shelf.slug,
+          items,
+        });
+      }
+    }
+
+    return {
+      continueWatching: continueItems,
+      shelves: rows,
+    };
+  }
+
+  async shelfItems(shelfId: string, kind: "MOVIE" | "SERIES", take: number) {
+    if (kind === "MOVIE") {
+      const files = await prisma.mediaFile.findMany({
+        where: { shelfId, available: true, movieId: { not: null } },
+        include: { movie: true },
+        orderBy: { updatedAt: "desc" },
+        take: take * 3,
+      });
+      const seen = new Set<string>();
+      const out = [];
+      for (const f of files) {
+        if (!f.movie || seen.has(f.movie.id)) continue;
+        seen.add(f.movie.id);
+        out.push({
+          type: "movie" as const,
+          id: f.movie.id,
+          title: f.movie.title,
+          year: f.movie.year,
+          posterUrl: f.movie.posterUrl,
+          backdropUrl: f.movie.backdropUrl,
+          mediaFileId: f.id,
+        });
+        if (out.length >= take) break;
+      }
+      return out;
+    }
+
+    const files = await prisma.mediaFile.findMany({
+      where: { shelfId, available: true, episodeId: { not: null } },
+      include: { episode: { include: { series: true } } },
+      orderBy: { updatedAt: "desc" },
+      take: take * 5,
+    });
+    const seen = new Set<string>();
+    const out = [];
+    for (const f of files) {
+      const series = f.episode?.series;
+      if (!series || seen.has(series.id)) continue;
+      seen.add(series.id);
+      out.push({
+        type: "series" as const,
+        id: series.id,
+        title: series.title,
+        year: series.year,
+        posterUrl: series.posterUrl,
+        backdropUrl: series.backdropUrl,
+      });
+      if (out.length >= take) break;
+    }
+    return out;
+  }
+
+  async continueWatching(viewerId: string) {
+    const rows = await prisma.watchProgress.findMany({
+      where: {
+        viewerUserId: viewerId,
+        hiddenFromContinue: false,
+        completed: false,
+        positionMs: { gt: 30_000 },
+      },
+      orderBy: { updatedAt: "desc" },
+      take: 24,
+    });
+
+    const out = [];
+    for (const p of rows) {
+      if (p.mediaType === "MOVIE" && p.movieId) {
+        const movie = await prisma.movie.findUnique({ where: { id: p.movieId } });
+        if (!movie) continue;
+        const file = await prisma.mediaFile.findFirst({
+          where: { movieId: movie.id, available: true },
+          orderBy: { updatedAt: "desc" },
+        });
+        out.push({
+          type: "movie" as const,
+          id: movie.id,
+          title: movie.title,
+          year: movie.year,
+          posterUrl: movie.posterUrl,
+          backdropUrl: movie.backdropUrl,
+          mediaFileId: file?.id ?? null,
+          positionMs: p.positionMs,
+          durationMs: p.durationMs,
+          progressId: p.id,
+        });
+      } else if (p.mediaType === "EPISODE" && p.episodeId) {
+        const episode = await prisma.episode.findUnique({
+          where: { id: p.episodeId },
+          include: { series: true },
+        });
+        if (!episode) continue;
+        const file = await prisma.mediaFile.findFirst({
+          where: { episodeId: episode.id, available: true },
+          orderBy: { updatedAt: "desc" },
+        });
+        out.push({
+          type: "episode" as const,
+          id: episode.id,
+          seriesId: episode.seriesId,
+          title: episode.series.title,
+          subtitle: `S${episode.seasonNumber}E${episode.episodeNumber}${
+            episode.title ? ` · ${episode.title}` : ""
+          }`,
+          year: episode.series.year,
+          posterUrl: episode.stillUrl || episode.series.posterUrl,
+          backdropUrl: episode.series.backdropUrl,
+          mediaFileId: file?.id ?? null,
+          positionMs: p.positionMs,
+          durationMs: p.durationMs,
+          progressId: p.id,
+        });
+      }
+    }
+    return out;
+  }
+
+  async upsertProgress(
+    viewerId: string,
+    body: {
+      mediaType: "MOVIE" | "EPISODE";
+      movieId?: string;
+      episodeId?: string;
+      seriesId?: string;
+      positionMs: number;
+      durationMs: number;
+      completed?: boolean;
+      hiddenFromContinue?: boolean;
+    }
+  ) {
+    const positionMs = Math.max(0, Math.floor(body.positionMs || 0));
+    const durationMs = Math.max(0, Math.floor(body.durationMs || 0));
+    const autoComplete =
+      body.completed === true ||
+      (durationMs > 0 && positionMs / durationMs >= 0.9);
+
+    if (body.mediaType === "MOVIE") {
+      if (!body.movieId) throw new AppError("INVALID_REQUEST", "movieId verplicht", 400);
+      return prisma.watchProgress.upsert({
+        where: {
+          viewerUserId_movieId: { viewerUserId: viewerId, movieId: body.movieId },
+        },
+        create: {
+          viewerUserId: viewerId,
+          mediaType: "MOVIE",
+          movieId: body.movieId,
+          positionMs,
+          durationMs,
+          completed: autoComplete,
+          hiddenFromContinue: body.hiddenFromContinue ?? false,
+        },
+        update: {
+          positionMs,
+          durationMs,
+          completed: body.completed ?? autoComplete,
+          ...(body.hiddenFromContinue !== undefined
+            ? { hiddenFromContinue: body.hiddenFromContinue }
+            : autoComplete
+              ? { hiddenFromContinue: true }
+              : {}),
+        },
+      });
+    }
+
+    if (!body.episodeId) throw new AppError("INVALID_REQUEST", "episodeId verplicht", 400);
+    let seriesId = body.seriesId ?? null;
+    if (!seriesId) {
+      const ep = await prisma.episode.findUnique({ where: { id: body.episodeId } });
+      seriesId = ep?.seriesId ?? null;
+    }
+    return prisma.watchProgress.upsert({
+      where: {
+        viewerUserId_episodeId: { viewerUserId: viewerId, episodeId: body.episodeId },
+      },
+      create: {
+        viewerUserId: viewerId,
+        mediaType: "EPISODE",
+        episodeId: body.episodeId,
+        seriesId,
+        positionMs,
+        durationMs,
+        completed: autoComplete,
+        hiddenFromContinue: body.hiddenFromContinue ?? false,
+      },
+      update: {
+        positionMs,
+        durationMs,
+        seriesId,
+        completed: body.completed ?? autoComplete,
+        ...(body.hiddenFromContinue !== undefined
+          ? { hiddenFromContinue: body.hiddenFromContinue }
+          : autoComplete
+            ? { hiddenFromContinue: true }
+            : {}),
+      },
+    });
+  }
+
+  async markWatched(viewerId: string, opts: { movieId?: string; episodeId?: string }) {
+    if (opts.movieId) {
+      return this.upsertProgress(viewerId, {
+        mediaType: "MOVIE",
+        movieId: opts.movieId,
+        positionMs: 1,
+        durationMs: 1,
+        completed: true,
+        hiddenFromContinue: true,
+      });
+    }
+    if (opts.episodeId) {
+      return this.upsertProgress(viewerId, {
+        mediaType: "EPISODE",
+        episodeId: opts.episodeId,
+        positionMs: 1,
+        durationMs: 1,
+        completed: true,
+        hiddenFromContinue: true,
+      });
+    }
+    throw new AppError("INVALID_REQUEST", "movieId of episodeId verplicht", 400);
+  }
+
+  async dismissContinue(viewerId: string, progressId: string) {
+    const row = await prisma.watchProgress.findFirst({
+      where: { id: progressId, viewerUserId: viewerId },
+    });
+    if (!row) throw new AppError("NOT_FOUND", "Niet gevonden", 404);
+    await prisma.watchProgress.update({
+      where: { id: progressId },
+      data: { hiddenFromContinue: true },
+    });
+    return { ok: true };
+  }
+
+  async getShelfPrefs(viewerId: string) {
+    const shelves = await prisma.libraryShelf.findMany({
+      where: { enabled: true },
+      orderBy: { sortOrder: "asc" },
+    });
+    const prefs = await prisma.viewerShelfPreference.findMany({
+      where: { viewerUserId: viewerId },
+    });
+    const prefMap = new Map(prefs.map((p) => [p.shelfId, p]));
+    return shelves.map((s, idx) => {
+      const pref = prefMap.get(s.id);
+      return {
+        shelfId: s.id,
+        name: s.name,
+        slug: s.slug,
+        kind: s.kind,
+        visible: pref?.visible ?? true,
+        sortOrder: pref?.sortOrder ?? s.sortOrder * 10 + idx,
+      };
+    });
+  }
+
+  async setShelfPrefs(
+    viewerId: string,
+    items: Array<{ shelfId: string; visible: boolean; sortOrder: number }>
+  ) {
+    for (const item of items) {
+      await prisma.viewerShelfPreference.upsert({
+        where: {
+          viewerUserId_shelfId: { viewerUserId: viewerId, shelfId: item.shelfId },
+        },
+        create: {
+          viewerUserId: viewerId,
+          shelfId: item.shelfId,
+          visible: item.visible,
+          sortOrder: item.sortOrder,
+        },
+        update: {
+          visible: item.visible,
+          sortOrder: item.sortOrder,
+        },
+      });
+    }
+    return this.getShelfPrefs(viewerId);
+  }
+
+  async movieDetail(movieId: string) {
+    const movie = await prisma.movie.findUnique({
+      where: { id: movieId },
+      include: {
+        mediaFiles: {
+          where: { available: true },
+          include: { node: { select: { id: true, name: true, status: true } } },
+          orderBy: { updatedAt: "desc" },
+        },
+      },
+    });
+    if (!movie) throw new AppError("NOT_FOUND", "Film niet gevonden", 404);
+    return {
+      type: "movie" as const,
+      id: movie.id,
+      title: movie.title,
+      year: movie.year,
+      overview: movie.overview,
+      posterUrl: movie.posterUrl,
+      backdropUrl: movie.backdropUrl,
+      runtime: movie.runtime,
+      genres: movie.genres,
+      mediaFiles: movie.mediaFiles.map((f) => ({
+        id: f.id,
+        resolution: f.resolution,
+        hdrType: f.hdrType,
+        videoCodec: f.videoCodec,
+        releaseName: f.releaseName,
+        nodeName: f.node.name,
+        nodeOnline: f.node.status === "ONLINE",
+      })),
+    };
+  }
+
+  async seriesDetail(seriesId: string) {
+    const series = await prisma.series.findUnique({
+      where: { id: seriesId },
+      include: {
+        seasons: {
+          orderBy: { seasonNumber: "asc" },
+          include: {
+            episodes: {
+              orderBy: { episodeNumber: "asc" },
+              include: {
+                mediaFiles: {
+                  where: { available: true },
+                  select: { id: true },
+                  take: 1,
+                },
+              },
+            },
+          },
+        },
+      },
+    });
+    if (!series) throw new AppError("NOT_FOUND", "Serie niet gevonden", 404);
+    return {
+      type: "series" as const,
+      id: series.id,
+      title: series.title,
+      year: series.year,
+      overview: series.overview,
+      posterUrl: series.posterUrl,
+      backdropUrl: series.backdropUrl,
+      seasons: series.seasons.map((s) => ({
+        seasonNumber: s.seasonNumber,
+        episodes: s.episodes.map((e) => ({
+          id: e.id,
+          seasonNumber: e.seasonNumber,
+          episodeNumber: e.episodeNumber,
+          title: e.title,
+          overview: e.overview,
+          stillUrl: e.stillUrl,
+          runtime: e.runtime,
+          mediaFileId: e.mediaFiles[0]?.id ?? null,
+          available: e.mediaFiles.length > 0,
+        })),
+      })),
+    };
+  }
+
+  async play(mediaFileId: string, viewerId: string) {
+    const session = await this.playback.createSession(mediaFileId, viewerId, undefined);
+    return {
+      streamUrl: session.streamUrl,
+      sessionId: session.sessionId,
+      mediaFileId: session.mediaFileId,
+    };
+  }
+
+  private publicBase(): string {
+    const base = (this.config.CLIENT_LINK_BASE_URL || this.config.PUBLIC_URL).replace(/\/+$/, "");
+    return base;
+  }
+}
+
+export async function requireViewer(
+  request: FastifyRequest,
+  service: ViewerService
+): Promise<AuthedViewer> {
+  return service.authFromBearer(request.headers.authorization);
+}