Update manifest.json for version 1.1.2

Jellyfin 12.0.0 targets net10.0, and the .NET 8 SDK refuses to even restore
a project that lists net10.0 among its TargetFrameworks (NETSDK1045) -- so
the multi-targeted net8.0;net10.0 build that will produce one plugin DLL per
Jellyfin generation cannot start until the builder image moves first.

Verified as a drop-in against the current net8-only master, inside the image:
restore + build are clean (0 errors, 0 warnings) and jprm produces the same
two-file zip as before. Analyzer levels still track each TFM, so the net8.0
leg stays warning-free; CA1873 will only need silencing on the net10.0 leg
once multi-targeting lands.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

.gitea/workflows/build.yaml

@@ -0,0 +1,92 @@
+name: '🏗️ Build Plugin'
+
+on:
+  push:
+    branches:
+      - master
+    paths-ignore:
+      - '**/*.md'
+  pull_request:
+    branches:
+      - master
+    paths-ignore:
+      - '**/*.md'
+  workflow_dispatch:
+
+jobs:
+  build:
+    runs-on: linux/amd64
+    container:
+      image: gitea.tourolle.paris/dtourolle/srfplay-builder:latest
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          path: build-${{ github.run_id }}
+
+      - name: Cache NuGet packages
+        uses: actions/cache@v3
+        with:
+          path: ~/.nuget/packages
+          key: nuget-${{ hashFiles('**/Jellyfin.Plugin.SRFPlay.csproj', '**/Jellyfin.Plugin.SRFPlay.Tests.csproj') }}
+          restore-keys: nuget-
+
+      - name: Restore dependencies
+        working-directory: build-${{ github.run_id }}
+        run: dotnet restore Jellyfin.Plugin.SRFPlay.sln
+
+      - name: Compute build version
+        id: version
+        run: |
+          # For PRs, stamp a distinct version so a side-loaded build is
+          # identifiable in Jellyfin: 1.0.<YYYYMMDD>-pr<N>.<run_number>.
+          # For plain master pushes, keep a date-based dev version.
+          DATE=$(date -u +"%Y%m%d")
+          if [ -n "${{ github.event.pull_request.number }}" ]; then
+            VERSION="1.0.${DATE}.${{ github.run_number }}"
+            LABEL="pr${{ github.event.pull_request.number }}"
+          else
+            VERSION="1.0.${DATE}.${{ github.run_number }}"
+            LABEL="master"
+          fi
+          echo "version=${VERSION}" >> $GITHUB_OUTPUT
+          echo "label=${LABEL}" >> $GITHUB_OUTPUT
+          echo "Build version: ${VERSION} (${LABEL})"
+
+      - name: Set build version
+        working-directory: build-${{ github.run_id }}
+        run: |
+          sed -i "s/^version:.*/version: \"${{ steps.version.outputs.version }}\"/" build.yaml
+
+      - name: Build solution
+        working-directory: build-${{ github.run_id }}
+        run: dotnet build Jellyfin.Plugin.SRFPlay.sln --configuration Release --no-restore --no-self-contained /m:1
+
+      - name: Run tests
+        working-directory: build-${{ github.run_id }}
+        run: dotnet test Jellyfin.Plugin.SRFPlay.sln --no-build --configuration Release --verbosity normal
+
+      - name: Build Jellyfin Plugin
+        id: jprm
+        working-directory: build-${{ github.run_id }}
+        run: |
+          mkdir -p artifacts
+          jprm --verbosity=debug plugin build .
+          ARTIFACT=$(find . -name "*.zip" -type f -print -quit | sed 's|^\./||')
+          LATEST="artifacts/srfplay_latest.zip"
+          cp "${ARTIFACT}" "${LATEST}"
+          echo "artifact=${LATEST}" >> $GITHUB_OUTPUT
+          echo "Found artifact: ${ARTIFACT} -> ${LATEST}"
+
+      - name: Upload build artifact
+        uses: actions/upload-artifact@v3
+        with:
+          name: srfplay-${{ steps.version.outputs.label }}-${{ steps.version.outputs.version }}
+          path: build-${{ github.run_id }}/${{ steps.jprm.outputs.artifact }}
+          retention-days: 30
+          if-no-files-found: error
+
+      - name: Cleanup
+        if: always()
+        run: rm -rf build-${{ github.run_id }}

.gitea/workflows/latest.yaml

@@ -0,0 +1,204 @@
+name: 'Nightly Build'
+
+on:
+  push:
+    branches:
+      - master
+    paths-ignore:
+      - '**/*.md'
+      - 'manifest.json'
+      - 'manifest-nightly.json'
+
+jobs:
+  nightly-build:
+    runs-on: linux/amd64
+    container:
+      image: gitea.tourolle.paris/dtourolle/srfplay-builder:latest
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          path: build-${{ github.run_id }}
+
+      - name: Compute nightly version
+        id: version
+        run: |
+          # Date-based nightly version: 1.0.<YYYYMMDD>.<run_number>
+          # The run_number suffix keeps multiple builds on the same day
+          # monotonically increasing so Jellyfin always offers the newest.
+          DATE=$(date -u +"%Y%m%d")
+          VERSION="1.0.${DATE}.${{ github.run_number }}"
+          echo "version=${VERSION}" >> $GITHUB_OUTPUT
+          echo "Nightly version: ${VERSION}"
+
+      - name: Set build version
+        working-directory: build-${{ github.run_id }}
+        run: |
+          VERSION="${{ steps.version.outputs.version }}"
+          sed -i "s/^version:.*/version: \"${VERSION}\"/" build.yaml
+          cat build.yaml
+
+      - name: Restore dependencies
+        working-directory: build-${{ github.run_id }}
+        run: dotnet restore Jellyfin.Plugin.SRFPlay.sln
+
+      - name: Build solution
+        working-directory: build-${{ github.run_id }}
+        run: dotnet build Jellyfin.Plugin.SRFPlay.sln --configuration Release --no-restore --no-self-contained /m:1
+
+      - name: Run tests
+        working-directory: build-${{ github.run_id }}
+        run: dotnet test Jellyfin.Plugin.SRFPlay.sln --no-build --configuration Release --verbosity normal
+
+      - name: Build Jellyfin Plugin
+        id: jprm
+        working-directory: build-${{ github.run_id }}
+        run: |
+          mkdir -p artifacts
+          jprm --verbosity=debug plugin build .
+          ARTIFACT=$(find . -name "*.zip" -type f -print -quit | sed 's|^\./||')
+          ARTIFACT_NAME=$(basename "${ARTIFACT}")
+          echo "artifact=${ARTIFACT}" >> $GITHUB_OUTPUT
+          echo "artifact_name=${ARTIFACT_NAME}" >> $GITHUB_OUTPUT
+          echo "Found artifact: ${ARTIFACT}"
+
+      - name: Calculate checksum
+        id: checksum
+        working-directory: build-${{ github.run_id }}
+        run: |
+          CHECKSUM=$(md5sum "${{ steps.jprm.outputs.artifact }}" | awk '{print $1}')
+          echo "checksum=${CHECKSUM}" >> $GITHUB_OUTPUT
+          echo "Checksum: ${CHECKSUM}"
+
+      - name: Delete existing nightly release
+        working-directory: build-${{ github.run_id }}
+        env:
+          GITEA_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          REPO_OWNER="${{ github.repository_owner }}"
+          REPO_NAME="${{ github.event.repository.name }}"
+          GITEA_URL="${{ github.server_url }}"
+          TAG="latest"
+
+          EXISTING=$(curl -s -o /dev/null -w "%{http_code}" \
+            -H "Authorization: token ${GITEA_TOKEN}" \
+            "${GITEA_URL}/api/v1/repos/${REPO_OWNER}/${REPO_NAME}/releases/tags/${TAG}")
+
+          if [ "$EXISTING" = "200" ]; then
+            RELEASE_ID=$(curl -s \
+              -H "Authorization: token ${GITEA_TOKEN}" \
+              "${GITEA_URL}/api/v1/repos/${REPO_OWNER}/${REPO_NAME}/releases/tags/${TAG}" | jq -r '.id')
+
+            echo "Deleting existing nightly release (ID: ${RELEASE_ID})..."
+            curl -s -X DELETE \
+              -H "Authorization: token ${GITEA_TOKEN}" \
+              "${GITEA_URL}/api/v1/repos/${REPO_OWNER}/${REPO_NAME}/releases/${RELEASE_ID}"
+          fi
+
+          curl -s -X DELETE \
+            -H "Authorization: token ${GITEA_TOKEN}" \
+            "${GITEA_URL}/api/v1/repos/${REPO_OWNER}/${REPO_NAME}/tags/${TAG}" || true
+
+      - name: Create nightly release
+        working-directory: build-${{ github.run_id }}
+        env:
+          GITEA_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          REPO_OWNER="${{ github.repository_owner }}"
+          REPO_NAME="${{ github.event.repository.name }}"
+          GITEA_URL="${{ github.server_url }}"
+          VERSION="${{ steps.version.outputs.version }}"
+          SHORT_SHA=$(echo "${{ github.sha }}" | cut -c1-7)
+
+          RESPONSE=$(curl -s -w "\n%{http_code}" -X POST \
+            -H "Authorization: token ${GITEA_TOKEN}" \
+            -H "Content-Type: application/json" \
+            "${GITEA_URL}/api/v1/repos/${REPO_OWNER}/${REPO_NAME}/releases" \
+            -d "$(jq -n --arg tag "latest" --arg name "Nightly Build ${VERSION}" --arg body "SRFPlay Jellyfin Plugin nightly build ${VERSION} from master (${SHORT_SHA})." '{tag_name: $tag, name: $name, body: $body, target_commitish: "master", draft: false, prerelease: true}')")
+
+          HTTP_CODE=$(echo "$RESPONSE" | tail -n1)
+          BODY=$(echo "$RESPONSE" | sed '$d')
+
+          if [ "$HTTP_CODE" -ge 200 ] && [ "$HTTP_CODE" -lt 300 ]; then
+            RELEASE_ID=$(echo "$BODY" | jq -r '.id')
+            echo "Created release with ID: ${RELEASE_ID}"
+          else
+            echo "Failed to create release. HTTP ${HTTP_CODE}"
+            echo "$BODY"
+            exit 1
+          fi
+
+          # Upload plugin artifact
+          echo "Uploading plugin artifact..."
+          curl -f -X POST \
+            -H "Authorization: token ${GITEA_TOKEN}" \
+            -H "Content-Type: application/zip" \
+            --data-binary "@${{ steps.jprm.outputs.artifact }}" \
+            "${GITEA_URL}/api/v1/repos/${REPO_OWNER}/${REPO_NAME}/releases/${RELEASE_ID}/assets?name=${{ steps.jprm.outputs.artifact_name }}"
+
+          # Upload build.yaml
+          echo "Uploading build.yaml..."
+          curl -f -X POST \
+            -H "Authorization: token ${GITEA_TOKEN}" \
+            -H "Content-Type: application/x-yaml" \
+            --data-binary "@build.yaml" \
+            "${GITEA_URL}/api/v1/repos/${REPO_OWNER}/${REPO_NAME}/releases/${RELEASE_ID}/assets?name=build.yaml"
+
+          echo "Nightly release updated successfully!"
+
+      - name: Update manifest-nightly.json
+        working-directory: build-${{ github.run_id }}
+        env:
+          GITEA_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          REPO_OWNER="${{ github.repository_owner }}"
+          REPO_NAME="${{ github.event.repository.name }}"
+          GITEA_URL="${{ github.server_url }}"
+          VERSION="${{ steps.version.outputs.version }}"
+          CHECKSUM="${{ steps.checksum.outputs.checksum }}"
+          ARTIFACT_NAME="${{ steps.jprm.outputs.artifact_name }}"
+          TIMESTAMP=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
+          DOWNLOAD_URL="${GITEA_URL}/${REPO_OWNER}/${REPO_NAME}/releases/download/latest/${ARTIFACT_NAME}"
+          SHORT_SHA=$(echo "${{ github.sha }}" | cut -c1-7)
+
+          git config user.name "Gitea Actions"
+          git config user.email "actions@gitea.tourolle.paris"
+          git fetch origin master
+          # -B against origin/master, not a bare `checkout master`. The bare
+          # form switches to the LOCAL master that actions/checkout left at the
+          # run's own SHA, so if master moved while the build ran -- and this is
+          # a nightly, so it usually has -- the manifest is edited on a stale
+          # base and the push is rejected non-fast-forward. Run 1045 failed
+          # exactly this way, having already printed "Your branch is behind
+          # 'origin/master' by 1 commit" one line before committing anyway.
+          #
+          # Resetting is right rather than merely convenient: this step appends
+          # one entry to the manifest as it stands on master, so the base it
+          # edits must be master, not whatever this build started from.
+          git checkout -B master origin/master
+
+          NEW_VERSION=$(cat <<EOF
+          {
+            "version": "${VERSION}",
+            "changelog": "Nightly build ${VERSION} (${SHORT_SHA})",
+            "targetAbi": "10.9.0.0",
+            "sourceUrl": "${DOWNLOAD_URL}",
+            "checksum": "${CHECKSUM}",
+            "timestamp": "${TIMESTAMP}"
+          }
+          EOF
+          )
+
+          # Prepend the new build and keep only the most recent 5 nightlies.
+          jq --argjson newver "${NEW_VERSION}" \
+            '.[0].versions = ([$newver] + .[0].versions)[0:5]' \
+            manifest-nightly.json > manifest.tmp && mv manifest.tmp manifest-nightly.json
+
+          git add manifest-nightly.json
+          git commit -m "Nightly: ${VERSION} (${SHORT_SHA})" || echo "No changes to commit"
+          git push origin master
+
+      - name: Cleanup
+        if: always()
+        run: rm -rf build-${{ github.run_id }}

.gitea/workflows/release.yaml

@@ -0,0 +1,171 @@
+name: '🚀 Release Plugin'
+
+on:
+  push:
+    tags:
+      - 'v*.*.*'
+  workflow_dispatch:
+    inputs:
+      version:
+        description: 'Version to release (e.g., v1.0.0)'
+        required: true
+        type: string
+
+jobs:
+  build-and-release:
+    runs-on: linux/amd64
+    container:
+      image: gitea.tourolle.paris/dtourolle/srfplay-builder:latest
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          path: release-${{ github.run_id }}
+
+      - name: Get version
+        id: get_version
+        run: |
+          if [ "${{ github.event_name }}" = "workflow_dispatch" ]; then
+            VERSION="${{ github.event.inputs.version }}"
+          else
+            VERSION="${GITHUB_REF#refs/tags/}"
+          fi
+          echo "version=${VERSION}" >> $GITHUB_OUTPUT
+          echo "version_number=${VERSION#v}" >> $GITHUB_OUTPUT
+          echo "Building version: ${VERSION}"
+
+      - name: Update build.yaml with version
+        working-directory: release-${{ github.run_id }}
+        run: |
+          VERSION="${{ steps.get_version.outputs.version_number }}"
+          sed -i "s/^version:.*/version: \"${VERSION}\"/" build.yaml
+          cat build.yaml
+
+      - name: Cache NuGet packages
+        uses: actions/cache@v3
+        with:
+          path: ~/.nuget/packages
+          key: nuget-${{ hashFiles('**/Jellyfin.Plugin.SRFPlay.csproj', '**/Jellyfin.Plugin.SRFPlay.Tests.csproj') }}
+          restore-keys: nuget-
+
+      - name: Restore dependencies
+        working-directory: release-${{ github.run_id }}
+        run: dotnet restore Jellyfin.Plugin.SRFPlay.sln
+
+      - name: Build solution
+        working-directory: release-${{ github.run_id }}
+        run: dotnet build Jellyfin.Plugin.SRFPlay.sln --configuration Release --no-restore --no-self-contained /m:1
+
+      - name: Run tests
+        working-directory: release-${{ github.run_id }}
+        run: dotnet test Jellyfin.Plugin.SRFPlay.sln --no-build --configuration Release --verbosity normal
+
+      - name: Build Jellyfin Plugin
+        id: jprm
+        working-directory: release-${{ github.run_id }}
+        run: |
+          mkdir -p artifacts
+          jprm --verbosity=debug plugin build ./
+          ARTIFACT=$(find . -name "*.zip" -type f -print -quit | sed 's|^\./||')
+          ARTIFACT_NAME=$(basename "${ARTIFACT}")
+          echo "artifact=${ARTIFACT}" >> $GITHUB_OUTPUT
+          echo "artifact_name=${ARTIFACT_NAME}" >> $GITHUB_OUTPUT
+          echo "Found artifact: ${ARTIFACT}"
+
+      - name: Calculate checksum
+        id: checksum
+        working-directory: release-${{ github.run_id }}
+        run: |
+          CHECKSUM=$(md5sum "${{ steps.jprm.outputs.artifact }}" | awk '{print $1}')
+          echo "checksum=${CHECKSUM}" >> $GITHUB_OUTPUT
+          echo "Checksum: ${CHECKSUM}"
+
+      - name: Create Release
+        working-directory: release-${{ github.run_id }}
+        env:
+          GITEA_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          # Get repository information
+          REPO_OWNER="${{ github.repository_owner }}"
+          REPO_NAME="${{ github.event.repository.name }}"
+          GITEA_URL="${{ github.server_url }}"
+
+          # Create release using Gitea API
+          VERSION="${{ steps.get_version.outputs.version }}"
+          RESPONSE=$(curl -s -w "\n%{http_code}" -X POST \
+            -H "Authorization: token ${GITEA_TOKEN}" \
+            -H "Content-Type: application/json" \
+            "${GITEA_URL}/api/v1/repos/${REPO_OWNER}/${REPO_NAME}/releases" \
+            -d "$(jq -n --arg tag "$VERSION" --arg name "Release $VERSION" --arg body "SRFPlay Jellyfin Plugin. See attached files for plugin installation." '{tag_name: $tag, name: $name, body: $body, draft: false, prerelease: false}')")
+
+          HTTP_CODE=$(echo "$RESPONSE" | tail -n1)
+          BODY=$(echo "$RESPONSE" | sed '$d')
+
+          if [ "$HTTP_CODE" -ge 200 ] && [ "$HTTP_CODE" -lt 300 ]; then
+            RELEASE_ID=$(echo "$BODY" | jq -r '.id')
+            echo "Created release with ID: ${RELEASE_ID}"
+          else
+            echo "Failed to create release. HTTP ${HTTP_CODE}"
+            echo "$BODY"
+            exit 1
+          fi
+
+          # Upload plugin artifact
+          echo "Uploading plugin artifact..."
+          curl -f -X POST \
+            -H "Authorization: token ${GITEA_TOKEN}" \
+            -H "Content-Type: application/zip" \
+            --data-binary "@${{ steps.jprm.outputs.artifact }}" \
+            "${GITEA_URL}/api/v1/repos/${REPO_OWNER}/${REPO_NAME}/releases/${RELEASE_ID}/assets?name=${{ steps.jprm.outputs.artifact_name }}"
+
+          # Upload build.yaml
+          echo "Uploading build.yaml..."
+          curl -f -X POST \
+            -H "Authorization: token ${GITEA_TOKEN}" \
+            -H "Content-Type: application/x-yaml" \
+            --data-binary "@build.yaml" \
+            "${GITEA_URL}/api/v1/repos/${REPO_OWNER}/${REPO_NAME}/releases/${RELEASE_ID}/assets?name=build.yaml"
+
+          echo "✅ Release created successfully!"
+          echo "View at: ${GITEA_URL}/${REPO_OWNER}/${REPO_NAME}/releases/tag/${{ steps.get_version.outputs.version }}"
+
+      - name: Update manifest.json
+        working-directory: release-${{ github.run_id }}
+        env:
+          GITEA_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          REPO_OWNER="${{ github.repository_owner }}"
+          REPO_NAME="${{ github.event.repository.name }}"
+          GITEA_URL="${{ github.server_url }}"
+          VERSION="${{ steps.get_version.outputs.version_number }}"
+          CHECKSUM="${{ steps.checksum.outputs.checksum }}"
+          ARTIFACT_NAME="${{ steps.jprm.outputs.artifact_name }}"
+          TIMESTAMP=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
+          DOWNLOAD_URL="${GITEA_URL}/${REPO_OWNER}/${REPO_NAME}/releases/download/${{ steps.get_version.outputs.version }}/${ARTIFACT_NAME}"
+
+          git config user.name "Gitea Actions"
+          git config user.email "actions@gitea.tourolle.paris"
+          git fetch origin master
+          git checkout master
+
+          NEW_VERSION=$(cat <<EOF
+          {
+            "version": "${VERSION}",
+            "changelog": "Release ${VERSION}",
+            "targetAbi": "10.9.0.0",
+            "sourceUrl": "${DOWNLOAD_URL}",
+            "checksum": "${CHECKSUM}",
+            "timestamp": "${TIMESTAMP}"
+          }
+          EOF
+          )
+
+          jq --argjson newver "${NEW_VERSION}" '.[0].versions = [$newver] + .[0].versions' manifest.json > manifest.tmp && mv manifest.tmp manifest.json
+          git add manifest.json
+          git commit -m "Update manifest.json for version ${VERSION}"
+          git push origin master
+
+      - name: Cleanup
+        if: always()
+        run: rm -rf release-${{ github.run_id }}

.gitea/workflows/test.yaml

@@ -0,0 +1,59 @@
+name: '🧪 Test Plugin'
+
+on:
+  push:
+    branches:
+      - master
+      - develop
+    paths-ignore:
+      - '**/*.md'
+  pull_request:
+    branches:
+      - master
+      - develop
+    paths-ignore:
+      - '**/*.md'
+  workflow_dispatch:
+
+jobs:
+  test:
+    runs-on: linux/amd64
+    container:
+      image: gitea.tourolle.paris/dtourolle/srfplay-builder:latest
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          path: test-${{ github.run_id }}
+
+      - name: Cache NuGet packages
+        uses: actions/cache@v3
+        with:
+          path: ~/.nuget/packages
+          key: nuget-${{ hashFiles('**/Jellyfin.Plugin.SRFPlay.csproj', '**/Jellyfin.Plugin.SRFPlay.Tests.csproj') }}
+          restore-keys: nuget-
+
+      - name: Restore dependencies
+        working-directory: test-${{ github.run_id }}
+        run: dotnet restore Jellyfin.Plugin.SRFPlay.sln
+
+      - name: Build solution
+        working-directory: test-${{ github.run_id }}
+        run: dotnet build Jellyfin.Plugin.SRFPlay.sln --configuration Debug --no-restore --no-self-contained /m:1
+
+      - name: Run tests
+        working-directory: test-${{ github.run_id }}
+        run: dotnet test Jellyfin.Plugin.SRFPlay.sln --no-build --configuration Debug --verbosity normal --logger "trx;LogFileName=test-results.trx"
+
+      - name: Upload test results
+        if: always()
+        uses: actions/upload-artifact@v3
+        with:
+          name: test-results
+          path: test-${{ github.run_id }}/**/test-results.trx
+          retention-days: 7
+
+      - name: Cleanup
+        if: always()
+        run: rm -rf test-${{ github.run_id }}

.gitignore

@@ -3,3 +3,4 @@ obj/
 .vs/
 .idea/
 artifacts
+*.log

.vscode/extensions.json

@@ -0,0 +1,11 @@
+{
+    // See https://go.microsoft.com/fwlink/?LinkId=827846 to learn about workspace recommendations.
+    // Extension identifier format: ${publisher}.${name}. Example: vscode.csharp
+    // List of extensions which should be recommended for users of this workspace.
+    "recommendations": [
+        "ms-dotnettools.csharp",
+        "editorconfig.editorconfig"
+    ],
+    // List of extensions recommended by VS Code that should not be recommended for users of this workspace.
+    "unwantedRecommendations": []
+}

.vscode/launch.json

@@ -7,7 +7,7 @@
             "name": "Launch",
             "request": "launch",
             "preLaunchTask": "build-and-copy",
-            "program": "${config:jellyfinDir}/bin/Debug/net6.0/jellyfin.dll",
+            "program": "${config:jellyfinDir}/bin/Debug/net8.0/jellyfin.dll",
             "args": [
                //"--nowebclient"
                "--webdir",

.vscode/settings.json

@@ -1,15 +1,19 @@
 {
     // jellyfinDir : The directory of the cloned jellyfin server project
     // This needs to be built once before it can be used
-    "jellyfinDir"     : "${workspaceFolder}/../jellyfin/Jellyfin.Server",
+    "jellyfinDir": "${workspaceFolder}/../jellyfin/Jellyfin.Server",
     // jellyfinWebDir : The directory of the cloned jellyfin-web project
     // This needs to be built once before it can be used
-    "jellyfinWebDir"  : "${workspaceFolder}/../jellyfin-web",
+    "jellyfinWebDir": "${workspaceFolder}/../jellyfin-web",
     // jellyfinDataDir : the root data directory for a running jellyfin instance
     // This is where jellyfin stores its configs, plugins, metadata etc
     // This is platform specific by default, but on Windows defaults to
     // ${env:LOCALAPPDATA}/jellyfin
-    "jellyfinDataDir" : "${env:LOCALAPPDATA}/jellyfin",
+    // and on Linux, it defaults to
+    // ${env:XDG_DATA_HOME}/jellyfin
+    // However ${env:XDG_DATA_HOME} does not work in Visual Studio Code's development container!
+    "jellyfinWindowsDataDir": "${env:LOCALAPPDATA}/jellyfin",
+    "jellyfinLinuxDataDir": "$HOME/.local/share/jellyfin",
     // The name of the plugin
-    "pluginName" : "Jellyfin.Plugin.Template",
+    "pluginName": "Jellyfin.Plugin.Template",
-}
+}

.vscode/tasks.json

@@ -7,7 +7,11 @@
       // jellyfin server's plugin directory
       "label": "build-and-copy",
       "dependsOrder": "sequence",
-      "dependsOn": ["build", "make-plugin-dir", "copy-dll"]
+      "dependsOn": [
+        "build",
+        "make-plugin-dir",
+        "copy-dll"
+      ]
     },
     {
       // Build the plugin
@@ -16,6 +20,7 @@
       "type": "shell",
       "args": [
         "publish",
+        "--configuration=Debug",
         "${workspaceFolder}/${config:pluginName}.sln",
         "/property:GenerateFullPaths=true",
         "/consoleloggerparameters:NoSummary"
@@ -27,29 +32,45 @@
       "problemMatcher": "$msCompile"
     },
     {
-        // Ensure the plugin directory exists before trying to use it
+      // Ensure the plugin directory exists before trying to use it
-        "label": "make-plugin-dir",
+      "label": "make-plugin-dir",
-        "type": "shell",
+      "type": "shell",
-        "command": "mkdir",
+      "command": "mkdir",
+      "windows": {
         "args": [
-           "-Force",
+          "-Force",
-           "-Path",
+          "-Path",
-           "${config:jellyfinDataDir}/plugins/${config:pluginName}/"
+          "${config:jellyfinWindowsDataDir}/plugins/${config:pluginName}/"
         ]
+      },
+      "linux": {
+        "args": [
+          "-p",
+          "${config:jellyfinLinuxDataDir}/plugins/${config:pluginName}/"
+        ]
+      }
     },
     {
-        // Copy the plugin dll to the jellyfin plugin install path
+      // Copy the plugin dll to the jellyfin plugin install path
-        // This command copies every .dll from the build directory to the plugin dir
+      // This command copies every .dll from the build directory to the plugin dir
-        // Usually, you probablly only need ${config:pluginName}.dll
+      // Usually, you probablly only need ${config:pluginName}.dll
-        // But some plugins may bundle extra requirements
+      // But some plugins may bundle extra requirements
-        "label": "copy-dll",
+      "label": "copy-dll",
-        "type": "shell",
+      "type": "shell",
-        "command": "cp",
+      "command": "cp",
+      "windows": {
         "args": [
-           "./${config:pluginName}/bin/Debug/net6.0/publish/*",
+          "./${config:pluginName}/bin/Debug/net8.0/publish/*",
-           "${config:jellyfinDataDir}/plugins/${config:pluginName}/"
+          "${config:jellyfinWindowsDataDir}/plugins/${config:pluginName}/"
         ]
-
+      },
+      "linux": {
+        "args": [
+          "-r",
+          "./${config:pluginName}/bin/Debug/net8.0/publish/*",
+          "${config:jellyfinLinuxDataDir}/plugins/${config:pluginName}/"
+        ]
+      }
     },
   ]
 }

DEBUG_GUIDE.md

@@ -0,0 +1,254 @@
+# Debugging Guide for SRF Play Plugin
+
+This guide helps you debug issues with the SRF Play plugin, including proxy configuration and content fetching problems.
+
+## Enhanced Logging
+
+The plugin now includes detailed logging to help diagnose issues. After installing the updated version, check your Jellyfin logs for these key messages.
+
+## Key Log Messages to Look For
+
+### 1. Proxy Configuration Status
+
+When the plugin initializes, you'll see:
+
+**Without proxy:**
+```
+[INF] SRFApiClient initializing without proxy
+```
+
+**With proxy:**
+```
+[INF] SRFApiClient initializing with proxy enabled: http://your-proxy:port
+[INF] Proxy configured: http://your-proxy:port (Authentication: True/False)
+```
+
+**Proxy configuration errors:**
+```
+[ERR] Failed to configure proxy: http://your-proxy:port
+```
+
+### 2. Media Composition Fetching
+
+For each video URN, you'll see detailed logs:
+
+```
+[INF] Fetching media composition for URN: urn:srf:video:12345 from https://il.srgssr.ch/integrationlayer/2.0/mediaComposition/byUrn/urn:srf:video:12345.json
+[INF] Media composition response for URN urn:srf:video:12345: StatusCode=OK
+[INF] Successfully fetched media composition for URN: urn:srf:video:12345 - Chapters: 1
+```
+
+**If there are no chapters:**
+```
+[WRN] Media composition for URN urn:srf:video:12345 has no chapters
+```
+
+**HTTP errors:**
+```
+[ERR] HTTP error fetching media composition for URN: urn:srf:video:12345 - StatusCode: 404
+```
+
+### 3. Stream URL Resolution
+
+For each chapter, you'll see detailed resource processing:
+
+```
+[INF] Processing chapter abc123 with 5 resources
+[INF] Chapter abc123: Total resources=5, Non-DRM resources=2
+[INF] Chapter abc123: HLS resources found=1
+```
+
+**DRM-protected content:**
+```
+[WRN] All resources for chapter abc123 require DRM
+[DBG] DRM resource: Protocol=HLS, Streaming=HLS, DRM=WIDEVINE
+```
+
+**No HLS streams:**
+```
+[WRN] No HLS resources found for chapter: abc123
+[DBG] Non-HLS resource: Protocol=HTTP, Streaming=PROGRESSIVE, URL=https://...
+[INF] Using fallback resource for chapter abc123: https://...
+```
+
+## Common Issues and Solutions
+
+### Issue 1: Videos Not Loading (Conversion Failures)
+
+**Symptoms:**
+```
+Conversion complete: 0 successful, 18 failed, 0 expired, 0 no stream
+```
+
+**Debugging steps:**
+
+1. **Check for DRM content:**
+   - Look for: `All resources for chapter XXX require DRM`
+   - Solution: This content cannot be played (Widevine DRM protection)
+
+2. **Check for HTTP errors:**
+   - Look for: `HTTP error fetching media composition` with status codes
+   - Common codes:
+     - `403 Forbidden`: Geo-restriction or blocked
+     - `404 Not Found`: Content removed or URN invalid
+     - `429 Too Many Requests`: Rate limiting
+   - Solution: Check if proxy is needed for geo-restrictions
+
+3. **Check for missing chapters:**
+   - Look for: `Media composition for URN XXX has no chapters`
+   - Solution: This video metadata is incomplete or invalid
+
+### Issue 2: Proxy Not Being Used
+
+**Symptoms:**
+- Plugin says "initializing without proxy" even though configured
+- Getting geo-restriction errors (403)
+
+**Debugging steps:**
+
+1. Check the initialization log:
+   ```
+   [INF] SRFApiClient initializing with proxy enabled: http://...
+   ```
+
+2. If it says "without proxy", check:
+   - Is "Use Proxy" checkbox enabled in plugin settings?
+   - Is the Proxy Address field filled in?
+   - Did you restart Jellyfin after saving?
+
+3. Check for proxy errors:
+   ```
+   [ERR] Failed to configure proxy: http://...
+   ```
+   - Verify the proxy URL format (must include `http://` or `socks5://`)
+   - Test proxy connectivity: `curl --proxy http://proxy:port https://il.srgssr.ch`
+
+### Issue 3: Proxy Connection Failures
+
+**Symptoms:**
+```
+[ERR] HTTP error fetching media composition for URN: ... - StatusCode: null
+```
+or timeout errors
+
+**Debugging steps:**
+
+1. **Verify proxy is reachable from Jellyfin server:**
+   ```bash
+   curl --proxy http://your-proxy:port https://il.srgssr.ch
+   ```
+
+2. **Check proxy authentication:**
+   - If proxy requires auth, ensure username/password are configured
+   - Look for: `Proxy configured: ... (Authentication: True)`
+
+3. **Check proxy supports HTTPS:**
+   - The SRF API uses HTTPS, ensure your proxy can handle it
+
+4. **Test with a simple HTTP proxy:**
+   ```bash
+   # Test with SSH tunnel as SOCKS5 proxy
+   ssh -D 1080 -N user@gateway-server
+   # Then configure: socks5://127.0.0.1:1080
+   ```
+
+### Issue 4: Content Expiration
+
+**Symptoms:**
+```
+Conversion complete: 0 successful, 0 failed, 10 expired, 0 no stream
+```
+
+**Solution:**
+- Content has expired and is no longer available
+- Check the expiration task runs regularly
+- Some content is time-limited by SRF
+
+## Enabling Debug Logs
+
+To see even more detailed logs (like `[DBG]` messages), modify your Jellyfin logging configuration:
+
+1. Go to **Dashboard → Logs**
+2. Click **Settings**
+3. Set log level to **Debug** for troubleshooting
+4. Restart Jellyfin
+
+**Warning:** Debug logging can be very verbose and consume disk space quickly. Only enable temporarily.
+
+## Testing Proxy Configuration
+
+To verify your proxy is working:
+
+### 1. Enable Proxy in Plugin Settings
+- Dashboard → Plugins → SRF Play
+- Check "Use Proxy"
+- Enter your proxy address
+- Save and restart Jellyfin
+
+### 2. Check Initialization Logs
+Look for:
+```
+[INF] SRFApiClient initializing with proxy enabled: http://your-proxy:port
+[INF] Proxy configured: http://your-proxy:port (Authentication: False)
+```
+
+### 3. Trigger Content Refresh
+- Dashboard → Scheduled Tasks → "Refresh SRF Play Content"
+- Run task manually
+- Watch logs for media composition requests
+
+### 4. Verify Requests Go Through Proxy
+You can monitor proxy logs (if available) or use network monitoring tools to confirm traffic routes through the proxy.
+
+## Getting Help
+
+When reporting issues, include:
+
+1. **Plugin version:**
+   - Dashboard → Plugins → SRF Play → Version
+
+2. **Relevant log entries:**
+   - The initialization message (with/without proxy)
+   - Any error messages
+   - The "Conversion complete" summary
+   - Resource processing details for failed items
+
+3. **Configuration:**
+   - Business unit selected
+   - Proxy enabled? (yes/no, don't share credentials)
+   - Where Jellyfin is running (local network, VPS, etc.)
+
+4. **Network environment:**
+   - Are you behind a geo-restriction?
+   - Is the proxy on the same network or remote?
+   - Any firewalls or network policies?
+
+## Example of Good Debug Output
+
+When everything works correctly with proxy:
+
+```
+[INF] SRFApiClient initializing with proxy enabled: http://192.168.1.1:3128
+[INF] Proxy configured: http://192.168.1.1:3128 (Authentication: False)
+[INF] Fetching media composition for URN: urn:srf:video:12345 from https://il.srgssr.ch/...
+[INF] Media composition response for URN urn:srf:video:12345: StatusCode=OK
+[INF] Successfully fetched media composition for URN: urn:srf:video:12345 - Chapters: 1
+[INF] Processing chapter abc123 with 3 resources
+[INF] Chapter abc123: Total resources=3, Non-DRM resources=2
+[INF] Chapter abc123: HLS resources found=1
+[DBG] Selected stream for chapter abc123: Quality=HD, Protocol=HLS, URL=https://...m3u8
+```
+
+## Example of Failed Conversion (DRM Issue)
+
+```
+[INF] Fetching media composition for URN: urn:srf:video:67890 from https://il.srgssr.ch/...
+[INF] Media composition response for URN urn:srf:video:67890: StatusCode=OK
+[INF] Successfully fetched media composition for URN: urn:srf:video:67890 - Chapters: 1
+[INF] Processing chapter def456 with 2 resources
+[INF] Chapter def456: Total resources=2, Non-DRM resources=0
+[WRN] All resources for chapter def456 require DRM
+[DBG] DRM resource: Protocol=HLS, Streaming=HLS, DRM=WIDEVINE
+```
+
+This means the content requires Widevine DRM and cannot be played by Jellyfin.

Directory.Build.targets

@@ -0,0 +1,17 @@
+<Project>
+  <!--
+    The Jellyfin meta build workflow rewrites Directory.Build.props, stamping Version,
+    AssemblyVersion and FileVersion all to a date-based value (e.g. 1.0.20260627.182).
+    The build segment (20260627) exceeds the 16-bit limit (0-65535) that AssemblyVersion
+    and FileVersion require, which fails the compile (CS7034/CS7035).
+
+    Directory.Build.targets is imported AFTER the project (and after Directory.Build.props),
+    and the workflow does not touch it, so we force valid assembly/file versions here. The
+    package/plugin manifest Version stays as injected; only the .NET assembly identity is
+    normalised, which is fine because Jellyfin identifies plugins by GUID + manifest version.
+  -->
+  <PropertyGroup>
+    <AssemblyVersion>1.0.0.0</AssemblyVersion>
+    <FileVersion>1.0.0.0</FileVersion>
+  </PropertyGroup>
+</Project>

Dockerfile.builder

@@ -0,0 +1,19 @@
+# SRFPlay Builder Image
+# Pre-built image with .NET SDK and JPRM for building Jellyfin plugins
+# Build: docker build -f Dockerfile.builder -t gitea.tourolle.paris/dtourolle/srfplay-builder:latest .
+# Push:  docker push gitea.tourolle.paris/dtourolle/srfplay-builder:latest
+
+FROM mcr.microsoft.com/dotnet/sdk:10.0
+
+RUN apt-get update && apt-get install -y \
+    python3 \
+    python3-pip \
+    git \
+    jq \
+    nodejs \
+    npm \
+    && rm -rf /var/lib/apt/lists/*
+
+RUN pip install --break-system-packages jprm
+
+WORKDIR /src

Jellyfin.Plugin.SRFPlay.Tests/Jellyfin.Plugin.SRFPlay.Tests.csproj

@@ -0,0 +1,19 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <ItemGroup>
+    <ProjectReference Include="../Jellyfin.Plugin.SRFPlay/Jellyfin.Plugin.SRFPlay.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.Extensions.Logging" Version="8.0.1" />
+    <PackageReference Include="Microsoft.Extensions.Logging.Console" Version="8.0.1" />
+  </ItemGroup>
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net8.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+</Project>

Jellyfin.Plugin.SRFPlay.Tests/Program.cs

@@ -0,0 +1,293 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net.Http;
+using System.Threading;
+using System.Threading.Tasks;
+using Jellyfin.Plugin.SRFPlay.Api;
+using Jellyfin.Plugin.SRFPlay.Api.Models;
+using Jellyfin.Plugin.SRFPlay.Configuration;
+using Jellyfin.Plugin.SRFPlay.Services;
+using Microsoft.Extensions.Logging;
+
+namespace Jellyfin.Plugin.SRFPlay.Tests
+{
+    /// <summary>
+    /// Simple IHttpClientFactory implementation for tests.
+    /// </summary>
+    internal sealed class TestHttpClientFactory : IHttpClientFactory
+    {
+        public HttpClient CreateClient(string name) => new HttpClient();
+    }
+
+    class Program
+    {
+        static async Task Main(string[] args)
+        {
+            // Run the new Play v3 API tests
+            await TestPlayV3Api.RunTests();
+
+            Console.WriteLine("\n\n");
+            Console.WriteLine("=================================================================");
+            Console.WriteLine("OLD API TESTS (DEPRECATED - Expected to fail)");
+            Console.WriteLine("=================================================================\n");
+
+            Console.WriteLine("=== SRFPlay Plugin Test Suite (Old API) ===\n");
+
+            // Setup logging
+            using var loggerFactory = LoggerFactory.Create(builder =>
+            {
+                builder.AddConsole();
+                builder.SetMinimumLevel(LogLevel.Warning); // Only show warnings and errors
+            });
+
+            var httpClientFactory = new TestHttpClientFactory();
+            var apiClient = new SRFApiClient(loggerFactory);
+            var streamResolver = new StreamUrlResolver(loggerFactory.CreateLogger<StreamUrlResolver>(), httpClientFactory);
+
+            var cancellationToken = CancellationToken.None;
+
+            // Test 1: Check API connectivity
+            Console.WriteLine("[Test 1] API Connectivity Test");
+            Console.WriteLine("-------------------------------");
+            try
+            {
+                var latestVideos = await apiClient.GetLatestVideosAsync("srf", cancellationToken);
+                if (latestVideos?.ChapterList != null && latestVideos.ChapterList.Any())
+                {
+                    Console.WriteLine($"✓ Successfully fetched latest videos: {latestVideos.ChapterList.Count} items");
+                    Console.WriteLine($"  First video: {latestVideos.ChapterList[0]?.Title}");
+                }
+                else
+                {
+                    Console.WriteLine("✗ Failed: No videos returned");
+                }
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"✗ Error: {ex.Message}");
+            }
+            Console.WriteLine();
+
+            // Test 2: Check trending videos
+            Console.WriteLine("[Test 2] Trending Videos Test");
+            Console.WriteLine("-----------------------------");
+            try
+            {
+                var trendingVideos = await apiClient.GetTrendingVideosAsync("srf", cancellationToken);
+                if (trendingVideos?.ChapterList != null && trendingVideos.ChapterList.Any())
+                {
+                    Console.WriteLine($"✓ Successfully fetched trending videos: {trendingVideos.ChapterList.Count} items");
+                    Console.WriteLine($"  First video: {trendingVideos.ChapterList[0]?.Title}");
+                }
+                else
+                {
+                    Console.WriteLine("✗ Failed: No videos returned");
+                }
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"✗ Error: {ex.Message}");
+            }
+            Console.WriteLine();
+
+            // Test 3: Get specific video and check stream URL
+            Console.WriteLine("[Test 3] Stream URL Resolution Test");
+            Console.WriteLine("-----------------------------------");
+            try
+            {
+                var latestVideos = await apiClient.GetLatestVideosAsync("srf", cancellationToken);
+                if (latestVideos?.ChapterList != null && latestVideos.ChapterList.Any())
+                {
+                    var firstChapter = latestVideos.ChapterList[0];
+                    Console.WriteLine($"Testing with: {firstChapter.Title}");
+                    Console.WriteLine($"URN: {firstChapter.Urn}");
+
+                    // Fetch full media composition for this URN
+                    var mediaComposition = await apiClient.GetMediaCompositionByUrnAsync(firstChapter.Urn, cancellationToken);
+
+                    if (mediaComposition?.ChapterList != null && mediaComposition.ChapterList.Any())
+                    {
+                        var chapter = mediaComposition.ChapterList[0];
+
+                        // Check if content is playable
+                        bool hasPlayableContent = streamResolver.HasPlayableContent(chapter);
+                        Console.WriteLine($"Has playable content: {hasPlayableContent}");
+
+                        // Check if content is expired
+                        bool isExpired = streamResolver.IsContentExpired(chapter);
+                        Console.WriteLine($"Is expired: {isExpired}");
+
+                        // Try to get stream URL
+                        if (hasPlayableContent && !isExpired)
+                        {
+                            var streamUrl = streamResolver.GetStreamUrl(chapter, Jellyfin.Plugin.SRFPlay.Configuration.QualityPreference.Auto);
+                            if (!string.IsNullOrEmpty(streamUrl))
+                            {
+                                Console.WriteLine($"✓ Stream URL resolved: {streamUrl.Substring(0, Math.Min(80, streamUrl.Length))}...");
+
+                                // Show available resources
+                                if (chapter.ResourceList != null)
+                                {
+                                    Console.WriteLine($"  Available resources: {chapter.ResourceList.Count}");
+                                    foreach (var resource in chapter.ResourceList.Take(5))
+                                    {
+                                        var hasDrm = resource.DrmList != null && resource.DrmList.ToString() != "[]";
+                                        Console.WriteLine($"    - {resource.Quality} ({resource.Protocol}) {(hasDrm ? "[DRM]" : "[No DRM]")}");
+                                    }
+                                }
+                            }
+                            else
+                            {
+                                Console.WriteLine("✗ Failed to resolve stream URL");
+                            }
+                        }
+                        else
+                        {
+                            if (!hasPlayableContent)
+                                Console.WriteLine("✗ Content is not playable (likely DRM protected)");
+                            if (isExpired)
+                                Console.WriteLine($"✗ Content is expired (ValidTo: {chapter.ValidTo})");
+                        }
+                    }
+                    else
+                    {
+                        Console.WriteLine("✗ Failed to fetch media composition");
+                    }
+                }
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"✗ Error: {ex.Message}");
+                Console.WriteLine($"Stack trace: {ex.StackTrace}");
+            }
+            Console.WriteLine();
+
+            // Test 4: Check multiple videos for playability
+            Console.WriteLine("[Test 4] Multiple Videos Playability Check");
+            Console.WriteLine("------------------------------------------");
+            try
+            {
+                var latestVideos = await apiClient.GetLatestVideosAsync("srf", cancellationToken);
+                if (latestVideos?.ChapterList != null)
+                {
+                    int totalVideos = Math.Min(10, latestVideos.ChapterList.Count);
+                    int playableCount = 0;
+                    int expiredCount = 0;
+                    int drmCount = 0;
+
+                    Console.WriteLine($"Checking {totalVideos} videos...\n");
+
+                    for (int i = 0; i < totalVideos; i++)
+                    {
+                        var chapter = latestVideos.ChapterList[i];
+                        var mediaComp = await apiClient.GetMediaCompositionByUrnAsync(chapter.Urn, cancellationToken);
+
+                        if (mediaComp?.ChapterList != null && mediaComp.ChapterList.Any())
+                        {
+                            var fullChapter = mediaComp.ChapterList[0];
+                            bool hasPlayable = streamResolver.HasPlayableContent(fullChapter);
+                            bool isExpired = streamResolver.IsContentExpired(fullChapter);
+
+                            string status;
+                            if (isExpired)
+                            {
+                                status = "EXPIRED";
+                                expiredCount++;
+                            }
+                            else if (!hasPlayable)
+                            {
+                                status = "DRM";
+                                drmCount++;
+                            }
+                            else
+                            {
+                                status = "PLAYABLE";
+                                playableCount++;
+                            }
+
+                            Console.WriteLine($"{i + 1}. [{status}] {fullChapter.Title}");
+                        }
+                    }
+
+                    Console.WriteLine();
+                    Console.WriteLine($"Summary:");
+                    Console.WriteLine($"  Playable: {playableCount}/{totalVideos} ({(playableCount * 100.0 / totalVideos):F1}%)");
+                    Console.WriteLine($"  DRM Protected: {drmCount}/{totalVideos} ({(drmCount * 100.0 / totalVideos):F1}%)");
+                    Console.WriteLine($"  Expired: {expiredCount}/{totalVideos} ({(expiredCount * 100.0 / totalVideos):F1}%)");
+                }
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"✗ Error: {ex.Message}");
+            }
+            Console.WriteLine();
+
+            // Test 5: Test library content discovery (simulates what would be in the library)
+            Console.WriteLine("[Test 5] Library Content Discovery Simulation");
+            Console.WriteLine("----------------------------------------------");
+            try
+            {
+                var latestVideos = await apiClient.GetLatestVideosAsync("srf", cancellationToken);
+                var trendingVideos = await apiClient.GetTrendingVideosAsync("srf", cancellationToken);
+
+                var allUrns = new HashSet<string>();
+
+                if (latestVideos?.ChapterList != null)
+                {
+                    foreach (var chapter in latestVideos.ChapterList)
+                    {
+                        if (!string.IsNullOrEmpty(chapter.Urn))
+                            allUrns.Add(chapter.Urn);
+                    }
+                }
+
+                if (trendingVideos?.ChapterList != null)
+                {
+                    foreach (var chapter in trendingVideos.ChapterList)
+                    {
+                        if (!string.IsNullOrEmpty(chapter.Urn))
+                            allUrns.Add(chapter.Urn);
+                    }
+                }
+
+                Console.WriteLine($"✓ Latest videos available: {latestVideos?.ChapterList?.Count ?? 0}");
+                Console.WriteLine($"✓ Trending videos available: {trendingVideos?.ChapterList?.Count ?? 0}");
+                Console.WriteLine($"✓ Total unique items for library (deduplicated): {allUrns.Count}");
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"✗ Error: {ex.Message}");
+            }
+            Console.WriteLine();
+
+            // Test 6: Test different business units
+            Console.WriteLine("[Test 6] Business Units Test");
+            Console.WriteLine("----------------------------");
+            var businessUnits = new[] { "srf", "rts", "rsi", "rtr", "swi" };
+
+            foreach (var bu in businessUnits)
+            {
+                try
+                {
+                    var videos = await apiClient.GetLatestVideosAsync(bu, cancellationToken);
+                    if (videos?.ChapterList != null && videos.ChapterList.Any())
+                    {
+                        Console.WriteLine($"✓ {bu.ToUpper()}: {videos.ChapterList.Count} videos available");
+                    }
+                    else
+                    {
+                        Console.WriteLine($"✗ {bu.ToUpper()}: No videos found");
+                    }
+                }
+                catch (Exception ex)
+                {
+                    Console.WriteLine($"✗ {bu.ToUpper()}: Error - {ex.Message}");
+                }
+            }
+            Console.WriteLine();
+
+            Console.WriteLine("=== Test Suite Complete ===");
+        }
+    }
+}

Jellyfin.Plugin.SRFPlay.Tests/TestPlayV3Api.cs

@@ -0,0 +1,220 @@
+using System;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Jellyfin.Plugin.SRFPlay.Api;
+using Microsoft.Extensions.Logging;
+
+namespace Jellyfin.Plugin.SRFPlay.Tests
+{
+    public class TestPlayV3Api
+    {
+        public static async Task RunTests()
+        {
+            Console.WriteLine("=== Play v3 API Test Suite ===\n");
+
+            using var loggerFactory = LoggerFactory.Create(builder =>
+            {
+                builder.AddConsole();
+                builder.SetMinimumLevel(LogLevel.Warning);
+            });
+
+            var apiClient = new SRFApiClient(loggerFactory);
+            var cancellationToken = CancellationToken.None;
+
+            // Test 1: Get all shows
+            Console.WriteLine("[Test 1] Fetch All Shows");
+            Console.WriteLine("------------------------");
+            try
+            {
+                var shows = await apiClient.GetAllShowsAsync("srf", cancellationToken);
+                if (shows != null && shows.Any())
+                {
+                    Console.WriteLine($"✓ Successfully fetched {shows.Count} shows");
+                    Console.WriteLine($"  First show: {shows[0]?.Title} ({shows[0]?.NumberOfEpisodes} episodes)");
+                    Console.WriteLine($"  Show ID: {shows[0]?.Id}");
+                    Console.WriteLine($"  URN: {shows[0]?.Urn}");
+                }
+                else
+                {
+                    Console.WriteLine("✗ Failed: No shows returned");
+                }
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"✗ Error: {ex.Message}");
+            }
+            Console.WriteLine();
+
+            // Test 2: Get videos for a show
+            Console.WriteLine("[Test 2] Fetch Videos for a Show");
+            Console.WriteLine("--------------------------------");
+            try
+            {
+                var shows = await apiClient.GetAllShowsAsync("srf", cancellationToken);
+                if (shows != null && shows.Any())
+                {
+                    // Find a show with episodes
+                    var showWithEpisodes = shows.FirstOrDefault(s => s.NumberOfEpisodes > 0);
+                    if (showWithEpisodes != null && showWithEpisodes.Id != null)
+                    {
+                        Console.WriteLine($"Testing with show: {showWithEpisodes.Title}");
+
+                        var videos = await apiClient.GetVideosForShowAsync("srf", showWithEpisodes.Id, cancellationToken);
+                        if (videos != null && videos.Any())
+                        {
+                            Console.WriteLine($"✓ Successfully fetched {videos.Count} videos");
+                            var firstVideo = videos[0];
+                            Console.WriteLine($"  First video: {firstVideo?.Title}");
+                            Console.WriteLine($"  URN: {firstVideo?.Urn}");
+                            Console.WriteLine($"  Duration: {firstVideo?.Duration / 1000}s");
+                            Console.WriteLine($"  Date: {firstVideo?.Date}");
+                            Console.WriteLine($"  Playable abroad: {firstVideo?.PlayableAbroad}");
+                        }
+                        else
+                        {
+                            Console.WriteLine("✗ Failed: No videos returned");
+                        }
+                    }
+                    else
+                    {
+                        Console.WriteLine("✗ Failed: No shows with episodes found");
+                    }
+                }
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"✗ Error: {ex.Message}");
+            }
+            Console.WriteLine();
+
+            // Test 3: Get video stream URL using Integration Layer
+            Console.WriteLine("[Test 3] Get Stream URL for Video");
+            Console.WriteLine("---------------------------------");
+            try
+            {
+                var shows = await apiClient.GetAllShowsAsync("srf", cancellationToken);
+                if (shows != null && shows.Any())
+                {
+                    var showWithEpisodes = shows.FirstOrDefault(s => s.NumberOfEpisodes > 0);
+                    if (showWithEpisodes != null && showWithEpisodes.Id != null)
+                    {
+                        var videos = await apiClient.GetVideosForShowAsync("srf", showWithEpisodes.Id, cancellationToken);
+                        if (videos != null && videos.Any())
+                        {
+                            var video = videos[0];
+                            if (video.Urn != null)
+                            {
+                                Console.WriteLine($"Fetching stream for: {video.Title}");
+
+                                // Use Integration Layer 2.0 to get stream URL
+                                var mediaComposition = await apiClient.GetMediaCompositionByUrnAsync(video.Urn, cancellationToken);
+                                if (mediaComposition?.ChapterList != null && mediaComposition.ChapterList.Any())
+                                {
+                                    var chapter = mediaComposition.ChapterList[0];
+                                    if (chapter.ResourceList != null && chapter.ResourceList.Any())
+                                    {
+                                        var hlsResource = chapter.ResourceList.FirstOrDefault(r =>
+                                            r.Protocol == "HLS" && r.IsPlayable);
+
+                                        if (hlsResource != null)
+                                        {
+                                            Console.WriteLine($"✓ Stream URL found:");
+                                            Console.WriteLine($"  URL: {hlsResource.Url?.Substring(0, Math.Min(80, hlsResource.Url?.Length ?? 0))}...");
+                                            Console.WriteLine($"  Quality: {hlsResource.Quality}");
+                                            Console.WriteLine($"  Protocol: {hlsResource.Protocol}");
+                                        }
+                                        else
+                                        {
+                                            Console.WriteLine("✗ No HLS stream without DRM found");
+                                        }
+                                    }
+                                    else
+                                    {
+                                        Console.WriteLine("✗ No resources found");
+                                    }
+                                }
+                                else
+                                {
+                                    Console.WriteLine("✗ Failed to fetch media composition");
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"✗ Error: {ex.Message}");
+            }
+            Console.WriteLine();
+
+            // Test 4: Check multiple shows
+            Console.WriteLine("[Test 4] Check Multiple Shows");
+            Console.WriteLine("----------------------------");
+            try
+            {
+                var shows = await apiClient.GetAllShowsAsync("srf", cancellationToken);
+                if (shows != null)
+                {
+                    var showsWithEpisodes = shows.Where(s => s.NumberOfEpisodes > 0).Take(10).ToList();
+                    Console.WriteLine($"Checking {showsWithEpisodes.Count} shows with episodes...\n");
+
+                    int successCount = 0;
+                    foreach (var show in showsWithEpisodes)
+                    {
+                        if (show.Id != null)
+                        {
+                            var videos = await apiClient.GetVideosForShowAsync("srf", show.Id, cancellationToken);
+                            if (videos != null && videos.Any())
+                            {
+                                Console.WriteLine($"✓ {show.Title}: {videos.Count} videos available");
+                                successCount++;
+                            }
+                            else
+                            {
+                                Console.WriteLine($"✗ {show.Title}: No videos found");
+                            }
+                        }
+                    }
+
+                    Console.WriteLine();
+                    Console.WriteLine($"Summary: {successCount}/{showsWithEpisodes.Count} shows successfully fetched videos");
+                }
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"✗ Error: {ex.Message}");
+            }
+            Console.WriteLine();
+
+            // Test 5: Test all business units
+            Console.WriteLine("[Test 5] Test All Business Units");
+            Console.WriteLine("--------------------------------");
+            var businessUnits = new[] { "srf", "rts", "rsi", "rtr", "swi" };
+
+            foreach (var bu in businessUnits)
+            {
+                try
+                {
+                    var shows = await apiClient.GetAllShowsAsync(bu, cancellationToken);
+                    if (shows != null && shows.Any())
+                    {
+                        Console.WriteLine($"✓ {bu.ToUpper()}: {shows.Count} shows available");
+                    }
+                    else
+                    {
+                        Console.WriteLine($"✗ {bu.ToUpper()}: No shows found");
+                    }
+                }
+                catch (Exception ex)
+                {
+                    Console.WriteLine($"✗ {bu.ToUpper()}: Error - {ex.Message}");
+                }
+            }
+            Console.WriteLine();
+
+            Console.WriteLine("=== Test Suite Complete ===");
+        }
+    }
+}

Jellyfin.Plugin.SRFPlay.sln

@@ -0,0 +1,42 @@
+Microsoft Visual Studio Solution File, Format Version 12.00
+# 
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Jellyfin.Plugin.SRFPlay", "Jellyfin.Plugin.SRFPlay\Jellyfin.Plugin.SRFPlay.csproj", "{D921B930-CF91-406F-ACBC-08914DCD0D34}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Jellyfin.Plugin.SRFPlay.Tests", "Jellyfin.Plugin.SRFPlay.Tests\Jellyfin.Plugin.SRFPlay.Tests.csproj", "{2F8A80BE-D938-42DE-B351-B705D154C1AE}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Debug|x64 = Debug|x64
+		Debug|x86 = Debug|x86
+		Release|Any CPU = Release|Any CPU
+		Release|x64 = Release|x64
+		Release|x86 = Release|x86
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{D921B930-CF91-406F-ACBC-08914DCD0D34}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{D921B930-CF91-406F-ACBC-08914DCD0D34}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{D921B930-CF91-406F-ACBC-08914DCD0D34}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{D921B930-CF91-406F-ACBC-08914DCD0D34}.Debug|x64.Build.0 = Debug|Any CPU
+		{D921B930-CF91-406F-ACBC-08914DCD0D34}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{D921B930-CF91-406F-ACBC-08914DCD0D34}.Debug|x86.Build.0 = Debug|Any CPU
+		{D921B930-CF91-406F-ACBC-08914DCD0D34}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{D921B930-CF91-406F-ACBC-08914DCD0D34}.Release|Any CPU.Build.0 = Release|Any CPU
+		{D921B930-CF91-406F-ACBC-08914DCD0D34}.Release|x64.ActiveCfg = Release|Any CPU
+		{D921B930-CF91-406F-ACBC-08914DCD0D34}.Release|x64.Build.0 = Release|Any CPU
+		{D921B930-CF91-406F-ACBC-08914DCD0D34}.Release|x86.ActiveCfg = Release|Any CPU
+		{D921B930-CF91-406F-ACBC-08914DCD0D34}.Release|x86.Build.0 = Release|Any CPU
+		{2F8A80BE-D938-42DE-B351-B705D154C1AE}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{2F8A80BE-D938-42DE-B351-B705D154C1AE}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{2F8A80BE-D938-42DE-B351-B705D154C1AE}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{2F8A80BE-D938-42DE-B351-B705D154C1AE}.Debug|x64.Build.0 = Debug|Any CPU
+		{2F8A80BE-D938-42DE-B351-B705D154C1AE}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{2F8A80BE-D938-42DE-B351-B705D154C1AE}.Debug|x86.Build.0 = Debug|Any CPU
+		{2F8A80BE-D938-42DE-B351-B705D154C1AE}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{2F8A80BE-D938-42DE-B351-B705D154C1AE}.Release|Any CPU.Build.0 = Release|Any CPU
+		{2F8A80BE-D938-42DE-B351-B705D154C1AE}.Release|x64.ActiveCfg = Release|Any CPU
+		{2F8A80BE-D938-42DE-B351-B705D154C1AE}.Release|x64.Build.0 = Release|Any CPU
+		{2F8A80BE-D938-42DE-B351-B705D154C1AE}.Release|x86.ActiveCfg = Release|Any CPU
+		{2F8A80BE-D938-42DE-B351-B705D154C1AE}.Release|x86.Build.0 = Release|Any CPU
+	EndGlobalSection
+EndGlobal

Jellyfin.Plugin.SRFPlay/Api/ISRFApiClientFactory.cs

@@ -0,0 +1,13 @@
+namespace Jellyfin.Plugin.SRFPlay.Api;
+
+/// <summary>
+/// Factory interface for creating SRF API clients.
+/// </summary>
+public interface ISRFApiClientFactory
+{
+    /// <summary>
+    /// Creates a new instance of the SRF API client.
+    /// </summary>
+    /// <returns>A new SRFApiClient instance.</returns>
+    SRFApiClient CreateClient();
+}

Jellyfin.Plugin.SRFPlay/Api/Models/Chapter.cs

@@ -0,0 +1,104 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Text.Json.Serialization;
+
+namespace Jellyfin.Plugin.SRFPlay.Api.Models;
+
+/// <summary>
+/// Represents a chapter (video/episode) in the SRF API response.
+/// </summary>
+public class Chapter
+{
+    /// <summary>
+    /// Gets or sets the unique identifier.
+    /// </summary>
+    [JsonPropertyName("id")]
+    public string Id { get; set; } = string.Empty;
+
+    /// <summary>
+    /// Gets or sets the URN (Uniform Resource Name).
+    /// </summary>
+    [JsonPropertyName("urn")]
+    public string Urn { get; set; } = string.Empty;
+
+    /// <summary>
+    /// Gets or sets the title.
+    /// </summary>
+    [JsonPropertyName("title")]
+    public string Title { get; set; } = string.Empty;
+
+    /// <summary>
+    /// Gets or sets the lead/description.
+    /// </summary>
+    [JsonPropertyName("lead")]
+    public string? Lead { get; set; }
+
+    /// <summary>
+    /// Gets or sets the description.
+    /// </summary>
+    [JsonPropertyName("description")]
+    public string? Description { get; set; }
+
+    /// <summary>
+    /// Gets or sets the image URL.
+    /// </summary>
+    [JsonPropertyName("imageUrl")]
+    public string? ImageUrl { get; set; }
+
+    /// <summary>
+    /// Gets or sets the duration in milliseconds.
+    /// </summary>
+    [JsonPropertyName("duration")]
+    public long Duration { get; set; }
+
+    /// <summary>
+    /// Gets or sets the publication date.
+    /// </summary>
+    [JsonPropertyName("date")]
+    public DateTime? Date { get; set; }
+
+    /// <summary>
+    /// Gets or sets the valid from date.
+    /// </summary>
+    [JsonPropertyName("validFrom")]
+    public DateTime? ValidFrom { get; set; }
+
+    /// <summary>
+    /// Gets or sets the valid to date (expiration).
+    /// </summary>
+    [JsonPropertyName("validTo")]
+    public DateTime? ValidTo { get; set; }
+
+    /// <summary>
+    /// Gets or sets the list of available resources (streams).
+    /// </summary>
+    [JsonPropertyName("resourceList")]
+    [System.Diagnostics.CodeAnalysis.SuppressMessage("Design", "CA1002:Do not expose generic lists", Justification = "Required for JSON deserialization")]
+    [System.Diagnostics.CodeAnalysis.SuppressMessage("Design", "CA2227:Collection properties should be read only", Justification = "Required for JSON deserialization")]
+    public List<Resource> ResourceList { get; set; } = new List<Resource>();
+
+    /// <summary>
+    /// Gets or sets the episode number.
+    /// </summary>
+    [JsonPropertyName("episodeNumber")]
+    public int? EpisodeNumber { get; set; }
+
+    /// <summary>
+    /// Gets or sets the season number.
+    /// </summary>
+    [JsonPropertyName("seasonNumber")]
+    public int? SeasonNumber { get; set; }
+
+    /// <summary>
+    /// Gets or sets the media type.
+    /// </summary>
+    [JsonPropertyName("mediaType")]
+    public string? MediaType { get; set; }
+
+    /// <summary>
+    /// Gets or sets the type (e.g., SCHEDULED_LIVESTREAM).
+    /// </summary>
+    [JsonPropertyName("type")]
+    public string? Type { get; set; }
+}

Jellyfin.Plugin.SRFPlay/Api/Models/Episode.cs

@@ -0,0 +1,64 @@
+using System;
+using System.Text.Json.Serialization;
+
+namespace Jellyfin.Plugin.SRFPlay.Api.Models;
+
+/// <summary>
+/// Represents an episode in the SRF API response.
+/// </summary>
+public class Episode
+{
+    /// <summary>
+    /// Gets or sets the unique identifier.
+    /// </summary>
+    [JsonPropertyName("id")]
+    public string Id { get; set; } = string.Empty;
+
+    /// <summary>
+    /// Gets or sets the URN.
+    /// </summary>
+    [JsonPropertyName("urn")]
+    public string? Urn { get; set; }
+
+    /// <summary>
+    /// Gets or sets the title.
+    /// </summary>
+    [JsonPropertyName("title")]
+    public string Title { get; set; } = string.Empty;
+
+    /// <summary>
+    /// Gets or sets the lead/description.
+    /// </summary>
+    [JsonPropertyName("lead")]
+    public string? Lead { get; set; }
+
+    /// <summary>
+    /// Gets or sets the description.
+    /// </summary>
+    [JsonPropertyName("description")]
+    public string? Description { get; set; }
+
+    /// <summary>
+    /// Gets or sets the image URL.
+    /// </summary>
+    [JsonPropertyName("imageUrl")]
+    public string? ImageUrl { get; set; }
+
+    /// <summary>
+    /// Gets or sets the episode number.
+    /// </summary>
+    [JsonPropertyName("episodeNumber")]
+    public int? EpisodeNumber { get; set; }
+
+    /// <summary>
+    /// Gets or sets the season number.
+    /// </summary>
+    [JsonPropertyName("seasonNumber")]
+    public int? SeasonNumber { get; set; }
+
+    /// <summary>
+    /// Gets or sets the publication date.
+    /// </summary>
+    [JsonPropertyName("publishedDate")]
+    public DateTime? PublishedDate { get; set; }
+}

Jellyfin.Plugin.SRFPlay/Api/Models/MediaComposition.cs

@@ -0,0 +1,34 @@
+using System.Collections.Generic;
+using System.Text.Json.Serialization;
+
+namespace Jellyfin.Plugin.SRFPlay.Api.Models;
+
+/// <summary>
+/// Represents the root media composition response from SRF API.
+/// </summary>
+public class MediaComposition
+{
+    /// <summary>
+    /// Gets or sets the list of chapters (videos/episodes).
+    /// </summary>
+    [JsonPropertyName("chapterList")]
+    public IReadOnlyList<Chapter> ChapterList { get; set; } = new List<Chapter>();
+
+    /// <summary>
+    /// Gets a value indicating whether this composition has any chapters.
+    /// </summary>
+    [JsonIgnore]
+    public bool HasChapters => ChapterList != null && ChapterList.Count > 0;
+
+    /// <summary>
+    /// Gets or sets the episode information.
+    /// </summary>
+    [JsonPropertyName("episode")]
+    public Episode? Episode { get; set; }
+
+    /// <summary>
+    /// Gets or sets the show information.
+    /// </summary>
+    [JsonPropertyName("show")]
+    public Show? Show { get; set; }
+}

Jellyfin.Plugin.SRFPlay/Api/Models/PlayV3/PlayV3DataContainer.cs

@@ -0,0 +1,26 @@
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.Text.Json.Serialization;
+
+namespace Jellyfin.Plugin.SRFPlay.Api.Models;
+
+/// <summary>
+/// Represents the data container in a Play v3 response.
+/// </summary>
+/// <typeparam name="T">The type of data items.</typeparam>
+public class PlayV3DataContainer<T>
+{
+    /// <summary>
+    /// Gets or sets the list of data items.
+    /// </summary>
+    [JsonPropertyName("data")]
+    [SuppressMessage("Usage", "CA2227:Collection properties should be read only", Justification = "Required for JSON deserialization")]
+    [SuppressMessage("Design", "CA1002:Do not expose generic lists", Justification = "DTO for JSON deserialization")]
+    public List<T>? Data { get; set; }
+
+    /// <summary>
+    /// Gets or sets the next page cursor.
+    /// </summary>
+    [JsonPropertyName("next")]
+    public string? Next { get; set; }
+}

Jellyfin.Plugin.SRFPlay/Api/Models/PlayV3/PlayV3DirectResponse.cs

@@ -0,0 +1,20 @@
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.Text.Json.Serialization;
+
+namespace Jellyfin.Plugin.SRFPlay.Api.Models;
+
+/// <summary>
+/// Represents a direct data response (for shows list).
+/// </summary>
+/// <typeparam name="T">The type of data items.</typeparam>
+public class PlayV3DirectResponse<T>
+{
+    /// <summary>
+    /// Gets or sets the list of data items.
+    /// </summary>
+    [JsonPropertyName("data")]
+    [SuppressMessage("Usage", "CA2227:Collection properties should be read only", Justification = "Required for JSON deserialization")]
+    [SuppressMessage("Design", "CA1002:Do not expose generic lists", Justification = "DTO for JSON deserialization")]
+    public List<T>? Data { get; set; }
+}

Jellyfin.Plugin.SRFPlay/Api/Models/PlayV3/PlayV3Response.cs

@@ -0,0 +1,16 @@
+using System.Text.Json.Serialization;
+
+namespace Jellyfin.Plugin.SRFPlay.Api.Models;
+
+/// <summary>
+/// Represents a paginated response from the Play v3 API.
+/// </summary>
+/// <typeparam name="T">The type of data items.</typeparam>
+public class PlayV3Response<T>
+{
+    /// <summary>
+    /// Gets or sets the data container.
+    /// </summary>
+    [JsonPropertyName("data")]
+    public PlayV3DataContainer<T>? Data { get; set; }
+}

Jellyfin.Plugin.SRFPlay/Api/Models/PlayV3/PlayV3Show.cs

@@ -0,0 +1,79 @@
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.Text.Json.Serialization;
+
+namespace Jellyfin.Plugin.SRFPlay.Api.Models;
+
+/// <summary>
+/// Represents a show from the Play v3 API.
+/// </summary>
+public class PlayV3Show
+{
+    /// <summary>
+    /// Gets or sets the show ID.
+    /// </summary>
+    [JsonPropertyName("id")]
+    public string? Id { get; set; }
+
+    /// <summary>
+    /// Gets or sets the show URN.
+    /// </summary>
+    [JsonPropertyName("urn")]
+    public string? Urn { get; set; }
+
+    /// <summary>
+    /// Gets or sets the show title.
+    /// </summary>
+    [JsonPropertyName("title")]
+    public string? Title { get; set; }
+
+    /// <summary>
+    /// Gets or sets the image URL.
+    /// </summary>
+    [JsonPropertyName("imageUrl")]
+    public string? ImageUrl { get; set; }
+
+    /// <summary>
+    /// Gets or sets the transmission type (TV or Radio).
+    /// </summary>
+    [JsonPropertyName("transmission")]
+    public string? Transmission { get; set; }
+
+    /// <summary>
+    /// Gets or sets the vendor/business unit.
+    /// </summary>
+    [JsonPropertyName("vendor")]
+    public string? Vendor { get; set; }
+
+    /// <summary>
+    /// Gets or sets the lead description.
+    /// </summary>
+    [JsonPropertyName("lead")]
+    public string? Lead { get; set; }
+
+    /// <summary>
+    /// Gets or sets the full description.
+    /// </summary>
+    [JsonPropertyName("description")]
+    public string? Description { get; set; }
+
+    /// <summary>
+    /// Gets or sets the poster image URL.
+    /// </summary>
+    [JsonPropertyName("posterImageUrl")]
+    public string? PosterImageUrl { get; set; }
+
+    /// <summary>
+    /// Gets or sets the number of episodes.
+    /// </summary>
+    [JsonPropertyName("numberOfEpisodes")]
+    public int NumberOfEpisodes { get; set; }
+
+    /// <summary>
+    /// Gets or sets the list of topic IDs.
+    /// </summary>
+    [JsonPropertyName("topicList")]
+    [SuppressMessage("Usage", "CA2227:Collection properties should be read only", Justification = "Required for JSON deserialization")]
+    [SuppressMessage("Design", "CA1002:Do not expose generic lists", Justification = "DTO for JSON deserialization")]
+    public List<string>? TopicList { get; set; }
+}

Jellyfin.Plugin.SRFPlay/Api/Models/PlayV3/PlayV3Topic.cs

@@ -0,0 +1,33 @@
+using System.Text.Json.Serialization;
+
+namespace Jellyfin.Plugin.SRFPlay.Api.Models;
+
+/// <summary>
+/// Represents a topic/category from the Play v3 API.
+/// </summary>
+public class PlayV3Topic
+{
+    /// <summary>
+    /// Gets or sets the topic ID (UUID).
+    /// </summary>
+    [JsonPropertyName("id")]
+    public string? Id { get; set; }
+
+    /// <summary>
+    /// Gets or sets the topic title.
+    /// </summary>
+    [JsonPropertyName("title")]
+    public string? Title { get; set; }
+
+    /// <summary>
+    /// Gets or sets the topic description/lead.
+    /// </summary>
+    [JsonPropertyName("lead")]
+    public string? Lead { get; set; }
+
+    /// <summary>
+    /// Gets or sets the transmission type (TV or Radio).
+    /// </summary>
+    [JsonPropertyName("transmission")]
+    public string? Transmission { get; set; }
+}

Jellyfin.Plugin.SRFPlay/Api/Models/PlayV3/PlayV3TvProgram.cs

@@ -0,0 +1,107 @@
+using System;
+using System.Collections.Generic;
+using System.Text.Json.Serialization;
+
+namespace Jellyfin.Plugin.SRFPlay.Api.Models.PlayV3;
+
+/// <summary>
+/// TV Program entry in the guide.
+/// </summary>
+public class PlayV3TvProgram
+{
+    /// <summary>
+    /// Gets or sets the URN identifier.
+    /// </summary>
+    [JsonPropertyName("urn")]
+    public string? Urn { get; set; }
+
+    /// <summary>
+    /// Gets or sets the title.
+    /// </summary>
+    [JsonPropertyName("title")]
+    public string? Title { get; set; }
+
+    /// <summary>
+    /// Gets or sets the lead/description.
+    /// </summary>
+    [JsonPropertyName("lead")]
+    public string? Lead { get; set; }
+
+    /// <summary>
+    /// Gets or sets the description.
+    /// </summary>
+    [JsonPropertyName("description")]
+    public string? Description { get; set; }
+
+    /// <summary>
+    /// Gets or sets the image URL.
+    /// </summary>
+    [JsonPropertyName("imageUrl")]
+    public string? ImageUrl { get; set; }
+
+    /// <summary>
+    /// Gets or sets the content type (e.g., SCHEDULED_LIVESTREAM).
+    /// </summary>
+    [JsonPropertyName("type")]
+    public string? Type { get; set; }
+
+    /// <summary>
+    /// Gets or sets the media type.
+    /// </summary>
+    [JsonPropertyName("mediaType")]
+    public string? MediaType { get; set; }
+
+    /// <summary>
+    /// Gets or sets the vendor (e.g., SRF, RTS).
+    /// </summary>
+    [JsonPropertyName("vendor")]
+    public string? Vendor { get; set; }
+
+    /// <summary>
+    /// Gets or sets the start time.
+    /// </summary>
+    [JsonPropertyName("date")]
+    public DateTime? Date { get; set; }
+
+    /// <summary>
+    /// Gets or sets the valid from time (for scheduled livestreams).
+    /// </summary>
+    [JsonPropertyName("validFrom")]
+    public DateTime? ValidFrom { get; set; }
+
+    /// <summary>
+    /// Gets or sets the valid to time (for scheduled livestreams).
+    /// </summary>
+    [JsonPropertyName("validTo")]
+    public DateTime? ValidTo { get; set; }
+
+    /// <summary>
+    /// Gets or sets the duration in milliseconds.
+    /// </summary>
+    [JsonPropertyName("duration")]
+    public long? Duration { get; set; }
+
+    /// <summary>
+    /// Gets or sets the channel ID.
+    /// </summary>
+    [JsonPropertyName("channelId")]
+    public string? ChannelId { get; set; }
+
+    /// <summary>
+    /// Gets or sets the channel title.
+    /// </summary>
+    [JsonPropertyName("channelTitle")]
+    public string? ChannelTitle { get; set; }
+
+    /// <summary>
+    /// Gets or sets whether this is blocked (DRM).
+    /// </summary>
+    [JsonPropertyName("blocked")]
+    public bool? Blocked { get; set; }
+
+    /// <summary>
+    /// Gets or sets whether this is geoblocked.
+    /// </summary>
+    [JsonPropertyName("geoblocked")]
+    public bool? Geoblocked { get; set; }
+}

Jellyfin.Plugin.SRFPlay/Api/Models/PlayV3/PlayV3Video.cs

@@ -0,0 +1,116 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.Text.Json.Serialization;
+
+namespace Jellyfin.Plugin.SRFPlay.Api.Models;
+
+/// <summary>
+/// Represents a video/episode from the Play v3 API.
+/// </summary>
+public class PlayV3Video
+{
+    /// <summary>
+    /// Gets or sets the video ID.
+    /// </summary>
+    [JsonPropertyName("id")]
+    public string? Id { get; set; }
+
+    /// <summary>
+    /// Gets or sets the video URN.
+    /// </summary>
+    [JsonPropertyName("urn")]
+    public string? Urn { get; set; }
+
+    /// <summary>
+    /// Gets or sets the video title.
+    /// </summary>
+    [JsonPropertyName("title")]
+    public string? Title { get; set; }
+
+    /// <summary>
+    /// Gets or sets the episode ID.
+    /// </summary>
+    [JsonPropertyName("episodeId")]
+    public string? EpisodeId { get; set; }
+
+    /// <summary>
+    /// Gets or sets the lead description.
+    /// </summary>
+    [JsonPropertyName("lead")]
+    public string? Lead { get; set; }
+
+    /// <summary>
+    /// Gets or sets the full description.
+    /// </summary>
+    [JsonPropertyName("description")]
+    public string? Description { get; set; }
+
+    /// <summary>
+    /// Gets or sets the image URL.
+    /// </summary>
+    [JsonPropertyName("imageUrl")]
+    public string? ImageUrl { get; set; }
+
+    /// <summary>
+    /// Gets or sets the duration in milliseconds.
+    /// </summary>
+    [JsonPropertyName("duration")]
+    public long Duration { get; set; }
+
+    /// <summary>
+    /// Gets or sets the publication date.
+    /// </summary>
+    [JsonPropertyName("date")]
+    public DateTime Date { get; set; }
+
+    /// <summary>
+    /// Gets or sets the valid from date.
+    /// </summary>
+    [JsonPropertyName("validFrom")]
+    public DateTime? ValidFrom { get; set; }
+
+    /// <summary>
+    /// Gets or sets the valid to date (expiration).
+    /// </summary>
+    [JsonPropertyName("validTo")]
+    public DateTime? ValidTo { get; set; }
+
+    /// <summary>
+    /// Gets or sets the media type (VIDEO or AUDIO).
+    /// </summary>
+    [JsonPropertyName("mediaType")]
+    public string? MediaType { get; set; }
+
+    /// <summary>
+    /// Gets or sets a value indicating whether subtitles are available.
+    /// </summary>
+    [JsonPropertyName("subtitlesAvailable")]
+    public bool SubtitlesAvailable { get; set; }
+
+    /// <summary>
+    /// Gets or sets a value indicating whether the content is playable abroad.
+    /// </summary>
+    [JsonPropertyName("playableAbroad")]
+    public bool PlayableAbroad { get; set; }
+
+    /// <summary>
+    /// Gets or sets the list of possible block reasons.
+    /// </summary>
+    [JsonPropertyName("possibleBlockReasons")]
+    [SuppressMessage("Usage", "CA2227:Collection properties should be read only", Justification = "Required for JSON deserialization")]
+    [SuppressMessage("Design", "CA1002:Do not expose generic lists", Justification = "DTO for JSON deserialization")]
+    public List<string>? PossibleBlockReasons { get; set; }
+
+    /// <summary>
+    /// Gets or sets the content type (EPISODE, CLIP, etc.).
+    /// </summary>
+    [JsonPropertyName("type")]
+    public string? Type { get; set; }
+
+    /// <summary>
+    /// Gets or sets the associated show information.
+    /// </summary>
+    [JsonPropertyName("show")]
+    public PlayV3Show? Show { get; set; }
+}

Jellyfin.Plugin.SRFPlay/Api/Models/RecordingEntry.cs

@@ -0,0 +1,101 @@
+using System;
+using System.Text.Json.Serialization;
+
+namespace Jellyfin.Plugin.SRFPlay.Api.Models;
+
+/// <summary>
+/// A scheduled or active recording.
+/// </summary>
+public class RecordingEntry
+{
+    /// <summary>
+    /// Gets or sets the unique recording ID.
+    /// </summary>
+    [JsonPropertyName("id")]
+    public string Id { get; set; } = string.Empty;
+
+    /// <summary>
+    /// Gets or sets the SRF URN.
+    /// </summary>
+    [JsonPropertyName("urn")]
+    public string Urn { get; set; } = string.Empty;
+
+    /// <summary>
+    /// Gets or sets the business unit this recording belongs to (e.g. "srf", "rts").
+    /// Used to show recordings under the matching unit's channel.
+    /// </summary>
+    [JsonPropertyName("businessUnit")]
+    public string BusinessUnit { get; set; } = string.Empty;
+
+    /// <summary>
+    /// Gets or sets the title.
+    /// </summary>
+    [JsonPropertyName("title")]
+    public string Title { get; set; } = string.Empty;
+
+    /// <summary>
+    /// Gets or sets the description.
+    /// </summary>
+    [JsonPropertyName("description")]
+    public string? Description { get; set; }
+
+    /// <summary>
+    /// Gets or sets the image URL.
+    /// </summary>
+    [JsonPropertyName("imageUrl")]
+    public string? ImageUrl { get; set; }
+
+    /// <summary>
+    /// Gets or sets when the livestream starts.
+    /// </summary>
+    [JsonPropertyName("validFrom")]
+    public DateTime? ValidFrom { get; set; }
+
+    /// <summary>
+    /// Gets or sets when the livestream ends.
+    /// </summary>
+    [JsonPropertyName("validTo")]
+    public DateTime? ValidTo { get; set; }
+
+    /// <summary>
+    /// Gets or sets the recording state.
+    /// </summary>
+    [JsonPropertyName("state")]
+    public RecordingState State { get; set; } = RecordingState.Scheduled;
+
+    /// <summary>
+    /// Gets or sets the output file path.
+    /// </summary>
+    [JsonPropertyName("outputPath")]
+    public string? OutputPath { get; set; }
+
+    /// <summary>
+    /// Gets or sets when the recording actually started.
+    /// </summary>
+    [JsonPropertyName("recordingStartedAt")]
+    public DateTime? RecordingStartedAt { get; set; }
+
+    /// <summary>
+    /// Gets or sets when the recording ended.
+    /// </summary>
+    [JsonPropertyName("recordingEndedAt")]
+    public DateTime? RecordingEndedAt { get; set; }
+
+    /// <summary>
+    /// Gets or sets the file size in bytes.
+    /// </summary>
+    [JsonPropertyName("fileSizeBytes")]
+    public long? FileSizeBytes { get; set; }
+
+    /// <summary>
+    /// Gets or sets the error message if recording failed.
+    /// </summary>
+    [JsonPropertyName("errorMessage")]
+    public string? ErrorMessage { get; set; }
+
+    /// <summary>
+    /// Gets or sets when this entry was created.
+    /// </summary>
+    [JsonPropertyName("createdAt")]
+    public DateTime CreatedAt { get; set; } = DateTime.UtcNow;
+}

Jellyfin.Plugin.SRFPlay/Api/Models/RecordingState.cs

@@ -0,0 +1,25 @@
+namespace Jellyfin.Plugin.SRFPlay.Api.Models;
+
+/// <summary>
+/// State of a recording.
+/// </summary>
+public enum RecordingState
+{
+    /// <summary>Scheduled for future recording.</summary>
+    Scheduled,
+
+    /// <summary>Waiting for stream to become available.</summary>
+    WaitingForStream,
+
+    /// <summary>Currently recording.</summary>
+    Recording,
+
+    /// <summary>Recording completed successfully.</summary>
+    Completed,
+
+    /// <summary>Recording failed.</summary>
+    Failed,
+
+    /// <summary>Recording was cancelled.</summary>
+    Cancelled
+}

Jellyfin.Plugin.SRFPlay/Api/Models/Resource.cs

@@ -0,0 +1,60 @@
+using System.Text.Json.Serialization;
+
+namespace Jellyfin.Plugin.SRFPlay.Api.Models;
+
+// NOTE: DrmList is typed as object? because the SRF API returns either null or a JSON array.
+// IsPlayable checks for both null and empty array ("[]") to determine if content is DRM-free.
+
+/// <summary>
+/// Represents a streaming resource (URL) in the SRF API response.
+/// </summary>
+public class Resource
+{
+    /// <summary>
+    /// Gets or sets the stream URL.
+    /// </summary>
+    [JsonPropertyName("url")]
+    public string Url { get; set; } = string.Empty;
+
+    /// <summary>
+    /// Gets or sets the streaming protocol (e.g., HLS, DASH).
+    /// </summary>
+    [JsonPropertyName("protocol")]
+    public string? Protocol { get; set; }
+
+    /// <summary>
+    /// Gets or sets the quality level (e.g., HD, SD).
+    /// </summary>
+    [JsonPropertyName("quality")]
+    public string? Quality { get; set; }
+
+    /// <summary>
+    /// Gets or sets the streaming method.
+    /// </summary>
+    [JsonPropertyName("streaming")]
+    public string? Streaming { get; set; }
+
+    /// <summary>
+    /// Gets or sets the MIME type.
+    /// </summary>
+    [JsonPropertyName("mimeType")]
+    public string? MimeType { get; set; }
+
+    /// <summary>
+    /// Gets or sets the encoding.
+    /// </summary>
+    [JsonPropertyName("encoding")]
+    public string? Encoding { get; set; }
+
+    /// <summary>
+    /// Gets or sets whether DRM is required.
+    /// </summary>
+    [JsonPropertyName("drmList")]
+    public object? DrmList { get; set; }
+
+    /// <summary>
+    /// Gets a value indicating whether this resource is playable (not DRM-protected).
+    /// </summary>
+    [JsonIgnore]
+    public bool IsPlayable => DrmList == null || DrmList.ToString() == "[]";
+}

Jellyfin.Plugin.SRFPlay/Api/Models/ResumeCleanupResult.cs

@@ -0,0 +1,29 @@
+using System.Collections.Generic;
+
+namespace Jellyfin.Plugin.SRFPlay.Api.Models;
+
+/// <summary>
+/// Outcome of a resume point ("Continue Watching") cleanup run.
+/// </summary>
+public class ResumeCleanupResult
+{
+    /// <summary>
+    /// Gets or sets the number of users whose resume list was inspected.
+    /// </summary>
+    public int UsersChecked { get; set; }
+
+    /// <summary>
+    /// Gets or sets the number of plugin-owned resume points that were inspected.
+    /// </summary>
+    public int Inspected { get; set; }
+
+    /// <summary>
+    /// Gets or sets the number of resume points that were cleared.
+    /// </summary>
+    public int Cleared { get; set; }
+
+    /// <summary>
+    /// Gets the number of cleared resume points grouped by the rule that matched.
+    /// </summary>
+    public Dictionary<string, int> ClearedByReason { get; } = new Dictionary<string, int>();
+}

Jellyfin.Plugin.SRFPlay/Api/Models/Show.cs

@@ -0,0 +1,63 @@
+using System.Text.Json.Serialization;
+
+namespace Jellyfin.Plugin.SRFPlay.Api.Models;
+
+/// <summary>
+/// Represents a show/program in the SRF API response.
+/// </summary>
+public class Show
+{
+    /// <summary>
+    /// Gets or sets the unique identifier.
+    /// </summary>
+    [JsonPropertyName("id")]
+    public string Id { get; set; } = string.Empty;
+
+    /// <summary>
+    /// Gets or sets the URN.
+    /// </summary>
+    [JsonPropertyName("urn")]
+    public string? Urn { get; set; }
+
+    /// <summary>
+    /// Gets or sets the title.
+    /// </summary>
+    [JsonPropertyName("title")]
+    public string Title { get; set; } = string.Empty;
+
+    /// <summary>
+    /// Gets or sets the lead/description.
+    /// </summary>
+    [JsonPropertyName("lead")]
+    public string? Lead { get; set; }
+
+    /// <summary>
+    /// Gets or sets the description.
+    /// </summary>
+    [JsonPropertyName("description")]
+    public string? Description { get; set; }
+
+    /// <summary>
+    /// Gets or sets the image URL.
+    /// </summary>
+    [JsonPropertyName("imageUrl")]
+    public string? ImageUrl { get; set; }
+
+    /// <summary>
+    /// Gets or sets the banner image URL.
+    /// </summary>
+    [JsonPropertyName("bannerImageUrl")]
+    public string? BannerImageUrl { get; set; }
+
+    /// <summary>
+    /// Gets or sets the vendor (business unit).
+    /// </summary>
+    [JsonPropertyName("vendor")]
+    public string? Vendor { get; set; }
+
+    /// <summary>
+    /// Gets or sets the transmission type.
+    /// </summary>
+    [JsonPropertyName("transmission")]
+    public string? Transmission { get; set; }
+}

Jellyfin.Plugin.SRFPlay/Api/SRFApiClient.cs

@@ -0,0 +1,466 @@
+using System;
+using System.Globalization;
+using System.Net;
+using System.Net.Http;
+using System.Text;
+using System.Text.Encodings.Web;
+using System.Text.Json;
+using System.Threading;
+using System.Threading.Tasks;
+using Jellyfin.Plugin.SRFPlay.Api.Models;
+using Jellyfin.Plugin.SRFPlay.Api.Models.PlayV3;
+using Jellyfin.Plugin.SRFPlay.Configuration;
+using Jellyfin.Plugin.SRFPlay.Constants;
+using Microsoft.Extensions.Logging;
+
+namespace Jellyfin.Plugin.SRFPlay.Api;
+
+/// <summary>
+/// HTTP client for interacting with the SRF Integration Layer API.
+/// </summary>
+public class SRFApiClient : IDisposable
+{
+    private readonly HttpClient _httpClient;
+    private readonly HttpClient _playV3HttpClient;
+    private readonly ILogger _logger;
+    private readonly JsonSerializerOptions _jsonOptions;
+    private readonly PluginConfiguration _configuration;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="SRFApiClient"/> class.
+    /// </summary>
+    /// <param name="loggerFactory">The logger factory.</param>
+    public SRFApiClient(ILoggerFactory loggerFactory)
+    {
+        _logger = loggerFactory.CreateLogger<SRFApiClient>();
+        _configuration = Plugin.Instance?.Configuration ?? new PluginConfiguration();
+
+        // Log proxy configuration status
+        if (_configuration.UseProxy && !string.IsNullOrWhiteSpace(_configuration.ProxyAddress))
+        {
+            _logger.LogInformation(
+                "SRFApiClient initializing with proxy enabled: {ProxyAddress}",
+                _configuration.ProxyAddress);
+        }
+        else
+        {
+            _logger.LogInformation("SRFApiClient initializing without proxy");
+        }
+
+        _httpClient = CreateHttpClient(ApiEndpoints.IntegrationLayerBaseUrl);
+        _playV3HttpClient = CreateHttpClient(null);
+
+        _jsonOptions = new JsonSerializerOptions
+        {
+            PropertyNameCaseInsensitive = true,
+            Encoder = JavaScriptEncoder.UnsafeRelaxedJsonEscaping
+        };
+    }
+
+    /// <summary>
+    /// Builds the Play v3 API base URL for a business unit. The host is normally
+    /// www.&lt;unit&gt;.ch, but SWI's site lives at www.swissinfo.ch (www.swi.ch is an
+    /// unrelated welding institute), while the API path segment stays the unit code.
+    /// </summary>
+    /// <param name="businessUnit">The lowercase business unit (e.g. "srf", "swi").</param>
+    /// <returns>The Play v3 production base URL ending in a slash.</returns>
+    private static string BuildPlayV3BaseUrl(string businessUnit)
+    {
+        var host = string.Equals(businessUnit, "swi", StringComparison.OrdinalIgnoreCase)
+            ? "www.swissinfo.ch"
+            : $"www.{businessUnit}.ch";
+        return $"https://{host}/play/v3/api/{businessUnit}/production/";
+    }
+
+    /// <summary>
+    /// Reads HTTP response content as UTF-8 string.
+    /// </summary>
+    /// <param name="content">The HTTP content to read.</param>
+    /// <param name="cancellationToken">The cancellation token.</param>
+    /// <returns>The content as a UTF-8 decoded string.</returns>
+    private async Task<string> ReadAsUtf8StringAsync(HttpContent content, CancellationToken cancellationToken = default)
+    {
+        var bytes = await content.ReadAsByteArrayAsync(cancellationToken).ConfigureAwait(false);
+        return Encoding.UTF8.GetString(bytes);
+    }
+
+    /// <summary>
+    /// Creates an HttpClient with optional proxy configuration.
+    /// </summary>
+    /// <param name="baseAddress">The base address for the HTTP client.</param>
+    /// <returns>Configured HttpClient.</returns>
+    [System.Diagnostics.CodeAnalysis.SuppressMessage("Security", "CA5399:HttpClient is created without enabling CheckCertificateRevocationList", Justification = "CRL check disabled for proxy compatibility")]
+    private HttpClient CreateHttpClient(string? baseAddress)
+    {
+        HttpClientHandler handler = new HttpClientHandler
+        {
+            CheckCertificateRevocationList = false, // Disable CRL check for proxy compatibility
+            AutomaticDecompression = System.Net.DecompressionMethods.All
+        };
+
+        // Configure proxy if enabled
+        if (_configuration.UseProxy && !string.IsNullOrWhiteSpace(_configuration.ProxyAddress))
+        {
+            try
+            {
+                var proxy = new WebProxy(_configuration.ProxyAddress);
+
+                // Add credentials if provided
+                if (!string.IsNullOrWhiteSpace(_configuration.ProxyUsername))
+                {
+                    proxy.Credentials = new NetworkCredential(
+                        _configuration.ProxyUsername,
+                        _configuration.ProxyPassword);
+                }
+
+                handler.Proxy = proxy;
+                handler.UseProxy = true;
+
+                _logger.LogInformation(
+                    "Proxy configured: {ProxyAddress} (Authentication: {HasAuth})",
+                    _configuration.ProxyAddress,
+                    !string.IsNullOrWhiteSpace(_configuration.ProxyUsername));
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "Failed to configure proxy: {ProxyAddress}", _configuration.ProxyAddress);
+                handler.UseProxy = false;
+            }
+        }
+
+        var client = new HttpClient(handler)
+        {
+            Timeout = TimeSpan.FromSeconds(30),
+            DefaultRequestVersion = HttpVersion.Version11, // Force HTTP/1.1
+            DefaultVersionPolicy = HttpVersionPolicy.RequestVersionExact // Ensure HTTP/1.1 is used, not upgraded
+        };
+
+        // Add browser headers - required by SRF API
+        client.DefaultRequestHeaders.UserAgent.ParseAdd("Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36");
+        client.DefaultRequestHeaders.Accept.ParseAdd("*/*");
+        client.DefaultRequestHeaders.AcceptLanguage.ParseAdd("en-US,en;q=0.9");
+        client.DefaultRequestHeaders.Add("Accept-Charset", "utf-8");
+
+        _logger.LogInformation(
+            "HttpClient created with HTTP/1.1 and headers - User-Agent: {UserAgent}, Accept: {Accept}, Accept-Language: {AcceptLanguage}",
+            client.DefaultRequestHeaders.UserAgent.ToString(),
+            client.DefaultRequestHeaders.Accept.ToString(),
+            client.DefaultRequestHeaders.AcceptLanguage.ToString());
+
+        if (!string.IsNullOrWhiteSpace(baseAddress))
+        {
+            client.BaseAddress = new Uri(baseAddress);
+        }
+
+        return client;
+    }
+
+    /// <summary>
+    /// Gets media composition by URN using curl as a fallback.
+    /// </summary>
+    /// <param name="urn">The URN of the content.</param>
+    /// <param name="cancellationToken">The cancellation token.</param>
+    /// <returns>The media composition.</returns>
+    public async Task<MediaComposition?> GetMediaCompositionByUrnAsync(string urn, CancellationToken cancellationToken = default)
+    {
+        try
+        {
+            var fullUrl = $"{ApiEndpoints.IntegrationLayerBaseUrl}/mediaComposition/byUrn/{urn}.json";
+            _logger.LogDebug("Fetching media composition for URN: {Urn} from {Url}", urn, fullUrl);
+
+            // Use curl - HttpClient returns 404 due to server routing/network configuration
+            return await FetchWithCurlAsync(fullUrl, cancellationToken).ConfigureAwait(false);
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Error fetching media composition for URN: {Urn}", urn);
+            return null;
+        }
+    }
+
+    /// <summary>
+    /// Fetches content using curl command as a fallback.
+    /// </summary>
+    /// <param name="url">The full URL to fetch.</param>
+    /// <param name="cancellationToken">The cancellation token.</param>
+    /// <returns>The deserialized media composition.</returns>
+    private async Task<MediaComposition?> FetchWithCurlAsync(string url, CancellationToken cancellationToken)
+    {
+        try
+        {
+            _logger.LogInformation("Using curl to fetch: {Url}", url);
+
+            var curlArgs = $"-s -H \"User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36\"";
+
+            // Add proxy if configured
+            if (_configuration.UseProxy && !string.IsNullOrWhiteSpace(_configuration.ProxyAddress))
+            {
+                curlArgs += $" -x {_configuration.ProxyAddress}";
+
+                if (!string.IsNullOrWhiteSpace(_configuration.ProxyUsername))
+                {
+                    curlArgs += $" -U {_configuration.ProxyUsername}:{_configuration.ProxyPassword}";
+                }
+
+                _logger.LogInformation("curl using proxy: {ProxyAddress}", _configuration.ProxyAddress);
+            }
+
+            curlArgs += $" \"{url}\"";
+
+            var processStartInfo = new System.Diagnostics.ProcessStartInfo
+            {
+                FileName = "curl",
+                Arguments = curlArgs,
+                RedirectStandardOutput = true,
+                RedirectStandardError = true,
+                UseShellExecute = false,
+                CreateNoWindow = true,
+                StandardOutputEncoding = Encoding.UTF8
+            };
+
+            using var process = new System.Diagnostics.Process { StartInfo = processStartInfo };
+            process.Start();
+
+            var output = await process.StandardOutput.ReadToEndAsync(cancellationToken).ConfigureAwait(false);
+            var error = await process.StandardError.ReadToEndAsync(cancellationToken).ConfigureAwait(false);
+
+            await process.WaitForExitAsync(cancellationToken).ConfigureAwait(false);
+
+            if (process.ExitCode != 0)
+            {
+                _logger.LogError("curl failed with exit code {ExitCode}: {Error}", process.ExitCode, error);
+                return null;
+            }
+
+            if (string.IsNullOrWhiteSpace(output))
+            {
+                _logger.LogWarning("curl returned empty response");
+                return null;
+            }
+
+            _logger.LogInformation("curl succeeded, response length: {Length}", output.Length);
+
+            var result = JsonSerializer.Deserialize<MediaComposition>(output, _jsonOptions);
+
+            if (result?.HasChapters == true)
+            {
+                _logger.LogInformation("Successfully fetched media composition via curl - Chapters: {ChapterCount}", result.ChapterList.Count);
+            }
+
+            return result;
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Error using curl to fetch URL: {Url}", url);
+            return null;
+        }
+    }
+
+    /// <summary>
+    /// Gets the latest videos for a business unit.
+    /// </summary>
+    /// <param name="businessUnit">The business unit (e.g., srf, rts).</param>
+    /// <param name="cancellationToken">The cancellation token.</param>
+    /// <returns>The media composition containing latest videos.</returns>
+    public Task<MediaComposition?> GetLatestVideosAsync(string businessUnit, CancellationToken cancellationToken = default)
+        => GetMediaCompositionListAsync(businessUnit, "latest", cancellationToken);
+
+    /// <summary>
+    /// Gets the trending videos for a business unit.
+    /// </summary>
+    /// <param name="businessUnit">The business unit (e.g., srf, rts).</param>
+    /// <param name="cancellationToken">The cancellation token.</param>
+    /// <returns>The media composition containing trending videos.</returns>
+    public Task<MediaComposition?> GetTrendingVideosAsync(string businessUnit, CancellationToken cancellationToken = default)
+        => GetMediaCompositionListAsync(businessUnit, "trending", cancellationToken);
+
+    private async Task<MediaComposition?> GetMediaCompositionListAsync(string businessUnit, string endpoint, CancellationToken cancellationToken)
+    {
+        try
+        {
+            var url = $"/video/{businessUnit}/{endpoint}.json";
+            _logger.LogInformation("Fetching {Endpoint} videos for business unit: {BusinessUnit} from URL: {Url}", endpoint, businessUnit, url);
+
+            var response = await _httpClient.GetAsync(url, cancellationToken).ConfigureAwait(false);
+
+            _logger.LogInformation("{Endpoint} videos API response: {StatusCode}", endpoint, response.StatusCode);
+
+            if (!response.IsSuccessStatusCode)
+            {
+                var errorContent = await ReadAsUtf8StringAsync(response.Content, cancellationToken).ConfigureAwait(false);
+                _logger.LogError("API returned error {StatusCode}: {Error}", response.StatusCode, errorContent);
+                return null;
+            }
+
+            var content = await ReadAsUtf8StringAsync(response.Content, cancellationToken).ConfigureAwait(false);
+            _logger.LogDebug("{Endpoint} videos response length: {Length}", endpoint, content.Length);
+
+            var result = JsonSerializer.Deserialize<MediaComposition>(content, _jsonOptions);
+
+            _logger.LogInformation("Successfully fetched {Endpoint} videos for business unit: {BusinessUnit}", endpoint, businessUnit);
+            return result;
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Error fetching {Endpoint} videos for business unit: {BusinessUnit}", endpoint, businessUnit);
+            return null;
+        }
+    }
+
+    /// <summary>
+    /// Gets all shows from the Play v3 API.
+    /// </summary>
+    /// <param name="businessUnit">The business unit (e.g., srf, rts).</param>
+    /// <param name="cancellationToken">The cancellation token.</param>
+    /// <returns>List of shows.</returns>
+    public Task<System.Collections.Generic.List<PlayV3Show>?> GetAllShowsAsync(string businessUnit, CancellationToken cancellationToken = default)
+        => GetPlayV3DirectListAsync<PlayV3Show>(businessUnit, "shows", cancellationToken);
+
+    /// <summary>
+    /// Gets all topics from the Play v3 API.
+    /// </summary>
+    /// <param name="businessUnit">The business unit (e.g., srf, rts).</param>
+    /// <param name="cancellationToken">The cancellation token.</param>
+    /// <returns>List of topics.</returns>
+    public Task<System.Collections.Generic.List<PlayV3Topic>?> GetAllTopicsAsync(string businessUnit, CancellationToken cancellationToken = default)
+        => GetPlayV3DirectListAsync<PlayV3Topic>(businessUnit, "topics", cancellationToken);
+
+    private async Task<System.Collections.Generic.List<T>?> GetPlayV3DirectListAsync<T>(string businessUnit, string endpoint, CancellationToken cancellationToken)
+    {
+        try
+        {
+            var baseUrl = BuildPlayV3BaseUrl(businessUnit);
+            var url = $"{baseUrl}{endpoint}";
+            _logger.LogInformation("Fetching all {Endpoint} for business unit: {BusinessUnit} from URL: {Url}", endpoint, businessUnit, url);
+
+            var response = await _playV3HttpClient.GetAsync(url, cancellationToken).ConfigureAwait(false);
+
+            if (!response.IsSuccessStatusCode)
+            {
+                var errorContent = await ReadAsUtf8StringAsync(response.Content, cancellationToken).ConfigureAwait(false);
+                _logger.LogError("API returned error {StatusCode}: {Error}", response.StatusCode, errorContent);
+                return null;
+            }
+
+            var content = await ReadAsUtf8StringAsync(response.Content, cancellationToken).ConfigureAwait(false);
+            var result = JsonSerializer.Deserialize<PlayV3DirectResponse<T>>(content, _jsonOptions);
+
+            _logger.LogInformation("Successfully fetched {Count} {Endpoint} for business unit: {BusinessUnit}", result?.Data?.Count ?? 0, endpoint, businessUnit);
+            return result?.Data;
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Error fetching {Endpoint} for business unit: {BusinessUnit}", endpoint, businessUnit);
+            return null;
+        }
+    }
+
+    /// <summary>
+    /// Gets videos for a specific show from the Play v3 API.
+    /// </summary>
+    /// <param name="businessUnit">The business unit (e.g., srf, rts).</param>
+    /// <param name="showId">The show ID.</param>
+    /// <param name="cancellationToken">The cancellation token.</param>
+    /// <returns>List of videos.</returns>
+    public async Task<System.Collections.Generic.List<PlayV3Video>?> GetVideosForShowAsync(string businessUnit, string showId, CancellationToken cancellationToken = default)
+    {
+        try
+        {
+            var baseUrl = BuildPlayV3BaseUrl(businessUnit);
+            var url = $"{baseUrl}videos-by-show-id?showId={showId}";
+            _logger.LogDebug("Fetching videos for show {ShowId} from business unit: {BusinessUnit}", showId, businessUnit);
+
+            var response = await _playV3HttpClient.GetAsync(url, cancellationToken).ConfigureAwait(false);
+
+            if (!response.IsSuccessStatusCode)
+            {
+                var errorContent = await ReadAsUtf8StringAsync(response.Content, cancellationToken).ConfigureAwait(false);
+                _logger.LogError("API returned error {StatusCode}: {Error}", response.StatusCode, errorContent);
+                return null;
+            }
+
+            var content = await ReadAsUtf8StringAsync(response.Content, cancellationToken).ConfigureAwait(false);
+            var result = JsonSerializer.Deserialize<PlayV3Response<PlayV3Video>>(content, _jsonOptions);
+
+            _logger.LogDebug("Successfully fetched {Count} videos for show {ShowId}", result?.Data?.Data?.Count ?? 0, showId);
+            return result?.Data?.Data;
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Error fetching videos for show {ShowId} from business unit: {BusinessUnit}", showId, businessUnit);
+            return null;
+        }
+    }
+
+    /// <summary>
+    /// Gets scheduled livestreams for sports or news events from the Play v3 API.
+    /// </summary>
+    /// <param name="businessUnit">The business unit (e.g., srf, rts).</param>
+    /// <param name="eventType">The event type (SPORT or NEWS).</param>
+    /// <param name="cancellationToken">The cancellation token.</param>
+    /// <returns>List of scheduled livestream entries.</returns>
+    public async Task<System.Collections.Generic.IReadOnlyList<PlayV3TvProgram>?> GetScheduledLivestreamsAsync(
+        string businessUnit,
+        string eventType = "SPORT",
+        CancellationToken cancellationToken = default)
+    {
+        try
+        {
+            var baseUrl = BuildPlayV3BaseUrl(businessUnit);
+            var url = $"{baseUrl}livestreams?eventType={eventType.ToUpperInvariant()}";
+            _logger.LogInformation("Fetching scheduled livestreams for eventType={EventType} from business unit: {BusinessUnit}", eventType, businessUnit);
+
+            var response = await _playV3HttpClient.GetAsync(url, cancellationToken).ConfigureAwait(false);
+
+            if (!response.IsSuccessStatusCode)
+            {
+                var errorContent = await ReadAsUtf8StringAsync(response.Content, cancellationToken).ConfigureAwait(false);
+                _logger.LogError("API returned error {StatusCode}: {Error}", response.StatusCode, errorContent);
+                return null;
+            }
+
+            var content = await ReadAsUtf8StringAsync(response.Content, cancellationToken).ConfigureAwait(false);
+
+            // The response structure is: { "data": { "scheduledLivestreams": [...] } }
+            var jsonDoc = JsonSerializer.Deserialize<JsonElement>(content, _jsonOptions);
+            if (jsonDoc.TryGetProperty("data", out var dataElement) &&
+                dataElement.TryGetProperty("scheduledLivestreams", out var livestreamsElement))
+            {
+                var livestreams = JsonSerializer.Deserialize<System.Collections.Generic.List<PlayV3TvProgram>>(
+                    livestreamsElement.GetRawText(),
+                    _jsonOptions);
+
+                _logger.LogInformation("Successfully fetched {Count} scheduled livestreams for eventType={EventType}", livestreams?.Count ?? 0, eventType);
+                return livestreams;
+            }
+
+            _logger.LogWarning("No scheduledLivestreams found in response");
+            return null;
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Error fetching scheduled livestreams for eventType={EventType} from business unit: {BusinessUnit}", eventType, businessUnit);
+            return null;
+        }
+    }
+
+    /// <inheritdoc/>
+    public void Dispose()
+    {
+        Dispose(true);
+        GC.SuppressFinalize(this);
+    }
+
+    /// <summary>
+    /// Releases the unmanaged resources and optionally releases the managed resources.
+    /// </summary>
+    /// <param name="disposing">True to release both managed and unmanaged resources; false to release only unmanaged resources.</param>
+    protected virtual void Dispose(bool disposing)
+    {
+        if (disposing)
+        {
+            _httpClient?.Dispose();
+            _playV3HttpClient?.Dispose();
+        }
+    }
+}

Jellyfin.Plugin.SRFPlay/Api/SRFApiClientFactory.cs

@@ -0,0 +1,26 @@
+using Microsoft.Extensions.Logging;
+
+namespace Jellyfin.Plugin.SRFPlay.Api;
+
+/// <summary>
+/// Factory for creating SRF API clients.
+/// </summary>
+public class SRFApiClientFactory : ISRFApiClientFactory
+{
+    private readonly ILoggerFactory _loggerFactory;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="SRFApiClientFactory"/> class.
+    /// </summary>
+    /// <param name="loggerFactory">The logger factory.</param>
+    public SRFApiClientFactory(ILoggerFactory loggerFactory)
+    {
+        _loggerFactory = loggerFactory;
+    }
+
+    /// <inheritdoc />
+    public SRFApiClient CreateClient()
+    {
+        return new SRFApiClient(_loggerFactory);
+    }
+}

Jellyfin.Plugin.SRFPlay/Channels/RsiChannel.cs

@@ -0,0 +1,43 @@
+using Jellyfin.Plugin.SRFPlay.Api;
+using Jellyfin.Plugin.SRFPlay.Configuration;
+using Jellyfin.Plugin.SRFPlay.Services.Interfaces;
+using Microsoft.Extensions.Logging;
+
+namespace Jellyfin.Plugin.SRFPlay.Channels;
+
+/// <summary>
+/// Radiotelevisione svizzera — Swiss Italian channel.
+/// </summary>
+public sealed class RsiChannel : SrgChannelBase
+{
+    /// <summary>
+    /// Initializes a new instance of the <see cref="RsiChannel"/> class.
+    /// </summary>
+    /// <param name="loggerFactory">The logger factory.</param>
+    /// <param name="contentRefreshService">The content refresh service.</param>
+    /// <param name="streamResolver">The stream resolver.</param>
+    /// <param name="mediaSourceFactory">The media source factory.</param>
+    /// <param name="categoryService">The category service.</param>
+    /// <param name="apiClientFactory">The API client factory.</param>
+    /// <param name="recordingService">The recording service.</param>
+    public RsiChannel(
+        ILoggerFactory loggerFactory,
+        IContentRefreshService contentRefreshService,
+        IStreamUrlResolver streamResolver,
+        IMediaSourceFactory mediaSourceFactory,
+        ICategoryService? categoryService,
+        ISRFApiClientFactory apiClientFactory,
+        IRecordingService recordingService)
+        : base(loggerFactory, contentRefreshService, streamResolver, mediaSourceFactory, categoryService, apiClientFactory, recordingService)
+    {
+    }
+
+    /// <inheritdoc />
+    protected override BusinessUnit Unit => BusinessUnit.RSI;
+
+    /// <inheritdoc />
+    protected override string LogoResourceName => "Jellyfin.Plugin.SRFPlay.Images.rsi-logo.png";
+
+    /// <inheritdoc />
+    public override string Description => "Radiotelevisione svizzera — Swiss Italian video-on-demand content";
+}

Jellyfin.Plugin.SRFPlay/Channels/RtrChannel.cs

@@ -0,0 +1,43 @@
+using Jellyfin.Plugin.SRFPlay.Api;
+using Jellyfin.Plugin.SRFPlay.Configuration;
+using Jellyfin.Plugin.SRFPlay.Services.Interfaces;
+using Microsoft.Extensions.Logging;
+
+namespace Jellyfin.Plugin.SRFPlay.Channels;
+
+/// <summary>
+/// Radiotelevisiun Svizra Rumantscha — Swiss Romansh channel.
+/// </summary>
+public sealed class RtrChannel : SrgChannelBase
+{
+    /// <summary>
+    /// Initializes a new instance of the <see cref="RtrChannel"/> class.
+    /// </summary>
+    /// <param name="loggerFactory">The logger factory.</param>
+    /// <param name="contentRefreshService">The content refresh service.</param>
+    /// <param name="streamResolver">The stream resolver.</param>
+    /// <param name="mediaSourceFactory">The media source factory.</param>
+    /// <param name="categoryService">The category service.</param>
+    /// <param name="apiClientFactory">The API client factory.</param>
+    /// <param name="recordingService">The recording service.</param>
+    public RtrChannel(
+        ILoggerFactory loggerFactory,
+        IContentRefreshService contentRefreshService,
+        IStreamUrlResolver streamResolver,
+        IMediaSourceFactory mediaSourceFactory,
+        ICategoryService? categoryService,
+        ISRFApiClientFactory apiClientFactory,
+        IRecordingService recordingService)
+        : base(loggerFactory, contentRefreshService, streamResolver, mediaSourceFactory, categoryService, apiClientFactory, recordingService)
+    {
+    }
+
+    /// <inheritdoc />
+    protected override BusinessUnit Unit => BusinessUnit.RTR;
+
+    /// <inheritdoc />
+    protected override string LogoResourceName => "Jellyfin.Plugin.SRFPlay.Images.rtr-logo.png";
+
+    /// <inheritdoc />
+    public override string Description => "Radiotelevisiun Svizra Rumantscha — Swiss Romansh video-on-demand content";
+}

Jellyfin.Plugin.SRFPlay/Channels/RtsChannel.cs

@@ -0,0 +1,43 @@
+using Jellyfin.Plugin.SRFPlay.Api;
+using Jellyfin.Plugin.SRFPlay.Configuration;
+using Jellyfin.Plugin.SRFPlay.Services.Interfaces;
+using Microsoft.Extensions.Logging;
+
+namespace Jellyfin.Plugin.SRFPlay.Channels;
+
+/// <summary>
+/// Radio Télévision Suisse — Swiss French channel.
+/// </summary>
+public sealed class RtsChannel : SrgChannelBase
+{
+    /// <summary>
+    /// Initializes a new instance of the <see cref="RtsChannel"/> class.
+    /// </summary>
+    /// <param name="loggerFactory">The logger factory.</param>
+    /// <param name="contentRefreshService">The content refresh service.</param>
+    /// <param name="streamResolver">The stream resolver.</param>
+    /// <param name="mediaSourceFactory">The media source factory.</param>
+    /// <param name="categoryService">The category service.</param>
+    /// <param name="apiClientFactory">The API client factory.</param>
+    /// <param name="recordingService">The recording service.</param>
+    public RtsChannel(
+        ILoggerFactory loggerFactory,
+        IContentRefreshService contentRefreshService,
+        IStreamUrlResolver streamResolver,
+        IMediaSourceFactory mediaSourceFactory,
+        ICategoryService? categoryService,
+        ISRFApiClientFactory apiClientFactory,
+        IRecordingService recordingService)
+        : base(loggerFactory, contentRefreshService, streamResolver, mediaSourceFactory, categoryService, apiClientFactory, recordingService)
+    {
+    }
+
+    /// <inheritdoc />
+    protected override BusinessUnit Unit => BusinessUnit.RTS;
+
+    /// <inheritdoc />
+    protected override string LogoResourceName => "Jellyfin.Plugin.SRFPlay.Images.rts-logo.png";
+
+    /// <inheritdoc />
+    public override string Description => "Radio Télévision Suisse — Swiss French video-on-demand content";
+}

Jellyfin.Plugin.SRFPlay/Channels/SrfChannel.cs

@@ -0,0 +1,43 @@
+using Jellyfin.Plugin.SRFPlay.Api;
+using Jellyfin.Plugin.SRFPlay.Configuration;
+using Jellyfin.Plugin.SRFPlay.Services.Interfaces;
+using Microsoft.Extensions.Logging;
+
+namespace Jellyfin.Plugin.SRFPlay.Channels;
+
+/// <summary>
+/// Schweizer Radio und Fernsehen — Swiss German channel.
+/// </summary>
+public sealed class SrfChannel : SrgChannelBase
+{
+    /// <summary>
+    /// Initializes a new instance of the <see cref="SrfChannel"/> class.
+    /// </summary>
+    /// <param name="loggerFactory">The logger factory.</param>
+    /// <param name="contentRefreshService">The content refresh service.</param>
+    /// <param name="streamResolver">The stream resolver.</param>
+    /// <param name="mediaSourceFactory">The media source factory.</param>
+    /// <param name="categoryService">The category service.</param>
+    /// <param name="apiClientFactory">The API client factory.</param>
+    /// <param name="recordingService">The recording service.</param>
+    public SrfChannel(
+        ILoggerFactory loggerFactory,
+        IContentRefreshService contentRefreshService,
+        IStreamUrlResolver streamResolver,
+        IMediaSourceFactory mediaSourceFactory,
+        ICategoryService? categoryService,
+        ISRFApiClientFactory apiClientFactory,
+        IRecordingService recordingService)
+        : base(loggerFactory, contentRefreshService, streamResolver, mediaSourceFactory, categoryService, apiClientFactory, recordingService)
+    {
+    }
+
+    /// <inheritdoc />
+    protected override BusinessUnit Unit => BusinessUnit.SRF;
+
+    /// <inheritdoc />
+    protected override string LogoResourceName => "Jellyfin.Plugin.SRFPlay.Images.srf-logo.png";
+
+    /// <inheritdoc />
+    public override string Description => "Schweizer Radio und Fernsehen — Swiss German video-on-demand content";
+}

Jellyfin.Plugin.SRFPlay/Channels/SrgChannelBase.cs

@@ -0,0 +1,708 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using Jellyfin.Plugin.SRFPlay.Api;
+using Jellyfin.Plugin.SRFPlay.Api.Models;
+using Jellyfin.Plugin.SRFPlay.Configuration;
+using Jellyfin.Plugin.SRFPlay.Constants;
+using Jellyfin.Plugin.SRFPlay.Services.Interfaces;
+using Jellyfin.Plugin.SRFPlay.Utilities;
+using MediaBrowser.Controller;
+using MediaBrowser.Controller.Channels;
+using MediaBrowser.Controller.Providers;
+using MediaBrowser.Model.Channels;
+using MediaBrowser.Model.Dto;
+using MediaBrowser.Model.Entities;
+using MediaBrowser.Model.MediaInfo;
+using Microsoft.Extensions.Logging;
+
+namespace Jellyfin.Plugin.SRFPlay.Channels;
+
+/// <summary>
+/// Base channel for browsing and playing content from a single SRG SSR business unit.
+/// One concrete subclass exists per unit (SRF, RTS, RSI, RTR, SWI), each shown as its own tile.
+/// </summary>
+public abstract class SrgChannelBase : IChannel, IHasCacheKey
+{
+    private readonly ILogger<SrgChannelBase> _logger;
+    private readonly IContentRefreshService _contentRefreshService;
+    private readonly IStreamUrlResolver _streamResolver;
+    private readonly IMediaSourceFactory _mediaSourceFactory;
+    private readonly ICategoryService? _categoryService;
+    private readonly ISRFApiClientFactory _apiClientFactory;
+    private readonly IRecordingService _recordingService;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="SrgChannelBase"/> class.
+    /// </summary>
+    /// <param name="loggerFactory">The logger factory.</param>
+    /// <param name="contentRefreshService">The content refresh service.</param>
+    /// <param name="streamResolver">The stream resolver.</param>
+    /// <param name="mediaSourceFactory">The media source factory.</param>
+    /// <param name="categoryService">The category service (optional).</param>
+    /// <param name="apiClientFactory">The API client factory.</param>
+    /// <param name="recordingService">The recording service.</param>
+    protected SrgChannelBase(
+        ILoggerFactory loggerFactory,
+        IContentRefreshService contentRefreshService,
+        IStreamUrlResolver streamResolver,
+        IMediaSourceFactory mediaSourceFactory,
+        ICategoryService? categoryService,
+        ISRFApiClientFactory apiClientFactory,
+        IRecordingService recordingService)
+    {
+        _logger = loggerFactory.CreateLogger<SrgChannelBase>();
+        _contentRefreshService = contentRefreshService;
+        _streamResolver = streamResolver;
+        _mediaSourceFactory = mediaSourceFactory;
+        _categoryService = categoryService;
+        _apiClientFactory = apiClientFactory;
+        _recordingService = recordingService;
+
+        if (_categoryService == null)
+        {
+            _logger.LogWarning("CategoryService not available - category folders will be disabled");
+        }
+
+        _logger.LogDebug("SrgChannelBase initialized");
+    }
+
+    /// <summary>
+    /// Gets the business unit this channel serves.
+    /// </summary>
+    protected abstract BusinessUnit Unit { get; }
+
+    /// <summary>
+    /// Gets the embedded resource name of this unit's logo PNG.
+    /// </summary>
+    protected abstract string LogoResourceName { get; }
+
+    /// <inheritdoc />
+    public string Name => $"{Unit} Play";
+
+    /// <inheritdoc />
+    public abstract string Description { get; }
+
+    /// <inheritdoc />
+    public string DataVersion => "2.0"; // Back to authenticating at channel refresh with auto-refresh for fresh tokens
+
+    /// <inheritdoc />
+    public string HomePageUrl => ApiEndpoints.SrfPlayHomepage;
+
+    /// <inheritdoc />
+    public ChannelParentalRating ParentalRating => ChannelParentalRating.GeneralAudience;
+
+    /// <inheritdoc />
+    public InternalChannelFeatures GetChannelFeatures()
+    {
+        _logger.LogDebug("GetChannelFeatures called");
+
+        return new InternalChannelFeatures
+        {
+            ContentTypes = new List<ChannelMediaContentType>
+            {
+                ChannelMediaContentType.Episode,
+                ChannelMediaContentType.Movie
+            },
+            MediaTypes = new List<ChannelMediaType>
+            {
+                ChannelMediaType.Video
+            },
+            SupportsSortOrderToggle = false,
+            DefaultSortFields = new List<ChannelItemSortField>
+            {
+                ChannelItemSortField.DateCreated,
+                ChannelItemSortField.Name
+            },
+            MaxPageSize = 50
+        };
+    }
+
+    /// <inheritdoc />
+    public Task<DynamicImageResponse> GetChannelImage(ImageType type, CancellationToken cancellationToken)
+    {
+        var assembly = GetType().Assembly;
+        var resourceStream = assembly.GetManifestResourceStream(LogoResourceName)
+            ?? assembly.GetManifestResourceStream("Jellyfin.Plugin.SRFPlay.Images.logo.png");
+
+        if (resourceStream == null)
+        {
+            return Task.FromResult(new DynamicImageResponse { HasImage = false });
+        }
+
+        return Task.FromResult(new DynamicImageResponse
+        {
+            HasImage = true,
+            Stream = resourceStream,
+            Format = MediaBrowser.Model.Drawing.ImageFormat.Png
+        });
+    }
+
+    /// <inheritdoc />
+    public IEnumerable<ImageType> GetSupportedChannelImages()
+    {
+        return new List<ImageType>
+        {
+            ImageType.Primary,
+            ImageType.Thumb
+        };
+    }
+
+    /// <inheritdoc />
+    public async Task<ChannelItemResult> GetChannelItems(InternalChannelItemQuery query, CancellationToken cancellationToken)
+    {
+        _logger.LogDebug("GetChannelItems called for folder {FolderId}", query.FolderId);
+
+        try
+        {
+            var items = await GetFolderItemsAsync(query.FolderId, cancellationToken).ConfigureAwait(false);
+            _logger.LogDebug("Returning {Count} channel items for folder {FolderId}", items.Count, query.FolderId);
+
+            return new ChannelItemResult
+            {
+                Items = items,
+                TotalRecordCount = items.Count
+            };
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Error getting channel items for folder {FolderId}", query.FolderId);
+            return new ChannelItemResult { Items = new List<ChannelItemInfo>(), TotalRecordCount = 0 };
+        }
+    }
+
+    private async Task<List<ChannelItemInfo>> GetFolderItemsAsync(string? folderId, CancellationToken cancellationToken)
+    {
+        // Root level - show folder list
+        if (string.IsNullOrEmpty(folderId))
+        {
+            return await GetRootFoldersAsync(cancellationToken).ConfigureAwait(false);
+        }
+
+        // Handle known folder types
+        return folderId switch
+        {
+            "latest" => await GetLatestVideosAsync(cancellationToken).ConfigureAwait(false),
+            "trending" => await GetTrendingVideosAsync(cancellationToken).ConfigureAwait(false),
+            "live_sports" => await GetLiveSportsAsync(cancellationToken).ConfigureAwait(false),
+            "recordings" => GetRecordingItems(),
+            _ when folderId.StartsWith("category_", StringComparison.Ordinal) => await GetCategoryVideosAsync(folderId, cancellationToken).ConfigureAwait(false),
+            _ => new List<ChannelItemInfo>()
+        };
+    }
+
+    private async Task<List<ChannelItemInfo>> GetRootFoldersAsync(CancellationToken cancellationToken)
+    {
+        var items = new List<ChannelItemInfo>
+        {
+            CreateFolder("latest", "Latest Videos"),
+            CreateFolder("trending", "Trending Videos"),
+            CreateFolder("live_sports", "Live Sports & Events"),
+            CreateFolder("recordings", "Recordings")
+        };
+
+        // Add category folders if enabled
+        var config = Plugin.Instance?.Configuration;
+        if (config?.EnableCategoryFolders == true && _categoryService != null)
+        {
+            try
+            {
+                var businessUnit = Unit.ToLowerString();
+                var topics = await _categoryService.GetTopicsAsync(businessUnit, cancellationToken).ConfigureAwait(false);
+
+                foreach (var topic in topics.Where(t => !string.IsNullOrEmpty(t.Id)))
+                {
+                    if (config.EnabledTopics != null && config.EnabledTopics.Count > 0 && !config.EnabledTopics.Contains(topic.Id!))
+                    {
+                        continue;
+                    }
+
+                    // Generate placeholder image for topic
+                    var placeholderUrl = CreatePlaceholderImageUrl(topic.Title ?? topic.Id!, _mediaSourceFactory.GetServerBaseUrl());
+                    items.Add(CreateFolder($"category_{topic.Id}", topic.Title ?? topic.Id!, topic.Lead, placeholderUrl));
+                }
+
+                _logger.LogInformation("Added {Count} category folders", topics.Count);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "Failed to load category folders - continuing without categories");
+            }
+        }
+
+        return items;
+    }
+
+    private static ChannelItemInfo CreateFolder(string id, string name, string? overview = null, string? imageUrl = null)
+    {
+        return new ChannelItemInfo
+        {
+            Id = id,
+            Name = name,
+            Type = ChannelItemType.Folder,
+            FolderType = ChannelFolderType.Container,
+            ImageUrl = imageUrl,
+            Overview = overview
+        };
+    }
+
+    private async Task<List<ChannelItemInfo>> GetLatestVideosAsync(CancellationToken cancellationToken)
+    {
+        var urns = await _contentRefreshService.RefreshLatestContentAsync(Unit.ToLowerString(), cancellationToken).ConfigureAwait(false);
+        return await ConvertUrnsToChannelItems(urns, cancellationToken).ConfigureAwait(false);
+    }
+
+    private async Task<List<ChannelItemInfo>> GetTrendingVideosAsync(CancellationToken cancellationToken)
+    {
+        var urns = await _contentRefreshService.RefreshTrendingContentAsync(Unit.ToLowerString(), cancellationToken).ConfigureAwait(false);
+        return await ConvertUrnsToChannelItems(urns, cancellationToken).ConfigureAwait(false);
+    }
+
+    private async Task<List<ChannelItemInfo>> GetLiveSportsAsync(CancellationToken cancellationToken)
+    {
+        var items = new List<ChannelItemInfo>();
+
+        try
+        {
+            var businessUnit = Unit.ToLowerString();
+
+            using var apiClient = _apiClientFactory.CreateClient();
+            var scheduledLivestreams = await apiClient.GetScheduledLivestreamsAsync(businessUnit, "SPORT", cancellationToken).ConfigureAwait(false);
+
+            if (scheduledLivestreams == null)
+            {
+                return items;
+            }
+
+            // Filter for upcoming/current events (within next 7 days)
+            var now = DateTime.UtcNow;
+            var weekFromNow = now.AddDays(7);
+
+            var upcomingEvents = scheduledLivestreams
+                .Where(p => p.Urn != null &&
+                           !string.IsNullOrEmpty(p.Title) &&
+                           p.ValidFrom != null &&
+                           p.ValidFrom.Value.ToUniversalTime() <= weekFromNow &&
+                           (p.ValidTo == null || p.ValidTo.Value.ToUniversalTime() > now))
+                .OrderBy(p => p.ValidFrom)
+                .ToList();
+
+            _logger.LogInformation("Found {Count} scheduled live sports events", upcomingEvents.Count);
+
+            var urns = upcomingEvents.Select(e => e.Urn!).ToList();
+            items = await ConvertUrnsToChannelItems(urns, cancellationToken).ConfigureAwait(false);
+
+            // Enhance items with scheduled time information
+            foreach (var item in items)
+            {
+                var matchingEvent = upcomingEvents.FirstOrDefault(e => item.ProviderIds.ContainsKey("SRF") && item.ProviderIds["SRF"] == e.Urn);
+                if (matchingEvent?.ValidFrom != null)
+                {
+                    var eventTime = matchingEvent.ValidFrom.Value;
+                    item.Name = $"[{eventTime:dd.MM HH:mm}] {matchingEvent.Title}";
+                    item.PremiereDate = eventTime;
+                }
+            }
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Failed to load live sports events");
+        }
+
+        return items;
+    }
+
+    private List<ChannelItemInfo> GetRecordingItems()
+    {
+        var items = new List<ChannelItemInfo>();
+        var unit = Unit.ToLowerString();
+        var recordings = _recordingService.GetRecordings(RecordingState.Completed);
+
+        foreach (var recording in recordings)
+        {
+            if (string.IsNullOrEmpty(recording.OutputPath) || !System.IO.File.Exists(recording.OutputPath))
+            {
+                continue;
+            }
+
+            // Only show recordings belonging to this unit. Recordings created before the
+            // BusinessUnit tag existed have an empty value and are shown everywhere so they
+            // are not lost.
+            if (!string.IsNullOrEmpty(recording.BusinessUnit) &&
+                !string.Equals(recording.BusinessUnit, unit, StringComparison.OrdinalIgnoreCase))
+            {
+                continue;
+            }
+
+            var fileInfo = new System.IO.FileInfo(recording.OutputPath);
+            var itemId = $"recording_{recording.Id}";
+
+            var mediaSource = new MediaSourceInfo
+            {
+                Id = itemId,
+                Name = recording.Title,
+                Path = recording.OutputPath,
+                Protocol = MediaProtocol.File,
+                Container = "mkv",
+                SupportsDirectPlay = true,
+                SupportsDirectStream = true,
+                SupportsTranscoding = true,
+                IsRemote = false,
+                Size = fileInfo.Length,
+                Type = MediaSourceType.Default
+            };
+
+            var item = new ChannelItemInfo
+            {
+                Id = itemId,
+                Name = recording.Title,
+                Overview = recording.Description,
+                Type = ChannelItemType.Media,
+                ContentType = ChannelMediaContentType.Movie,
+                MediaType = ChannelMediaType.Video,
+                DateCreated = recording.RecordingStartedAt,
+                ImageUrl = !string.IsNullOrEmpty(recording.ImageUrl)
+                    ? CreateProxiedImageUrl(recording.ImageUrl, _mediaSourceFactory.GetServerBaseUrl())
+                    : CreatePlaceholderImageUrl(recording.Title, _mediaSourceFactory.GetServerBaseUrl()),
+                MediaSources = new List<MediaSourceInfo> { mediaSource }
+            };
+
+            items.Add(item);
+        }
+
+        _logger.LogInformation("Returning {Count} completed recordings as channel items", items.Count);
+        return items;
+    }
+
+    private async Task<List<ChannelItemInfo>> GetCategoryVideosAsync(string folderId, CancellationToken cancellationToken)
+    {
+        var items = new List<ChannelItemInfo>();
+
+        if (_categoryService == null)
+        {
+            _logger.LogWarning("CategoryService not available - cannot display category folder");
+            return items;
+        }
+
+        try
+        {
+            var topicId = folderId.Substring("category_".Length);
+            var businessUnit = Unit.ToLowerString();
+
+            var shows = await _categoryService.GetShowsByTopicAsync(topicId, businessUnit, 20, cancellationToken).ConfigureAwait(false);
+            var urns = new List<string>();
+
+            using var apiClient = _apiClientFactory.CreateClient();
+
+            foreach (var show in shows)
+            {
+                if (show.Id == null || cancellationToken.IsCancellationRequested)
+                {
+                    continue;
+                }
+
+                try
+                {
+                    var latestUrn = await GetLatestVideoUrnForShowAsync(apiClient, businessUnit, show, topicId, cancellationToken).ConfigureAwait(false);
+                    if (latestUrn != null)
+                    {
+                        urns.Add(latestUrn);
+                    }
+                }
+                catch (Exception ex)
+                {
+                    _logger.LogWarning(ex, "Error fetching videos for show {ShowId} in category {TopicId}", show.Id, topicId);
+                }
+            }
+
+            items = await ConvertUrnsToChannelItems(urns, cancellationToken).ConfigureAwait(false);
+            _logger.LogInformation("Found {Count} videos for category {TopicId}", items.Count, topicId);
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Failed to load category videos");
+        }
+
+        return items;
+    }
+
+    private async Task<string?> GetLatestVideoUrnForShowAsync(
+        Api.SRFApiClient apiClient,
+        string businessUnit,
+        Api.Models.PlayV3Show show,
+        string topicId,
+        CancellationToken cancellationToken)
+    {
+        var videos = await apiClient.GetVideosForShowAsync(businessUnit, show.Id!, cancellationToken).ConfigureAwait(false);
+        if (videos == null || videos.Count == 0)
+        {
+            _logger.LogDebug("Category {TopicId}, Show {Show} ({ShowId}): No videos returned from API", topicId, show.Title, show.Id);
+            return null;
+        }
+
+        _logger.LogDebug("Category {TopicId}, Show {Show} ({ShowId}): Found {Count} videos", topicId, show.Title, show.Id, videos.Count);
+
+        // Filter to available videos
+        var now = DateTime.UtcNow;
+        var availableVideos = videos.Where(v =>
+            (v.ValidFrom == null || v.ValidFrom.Value.ToUniversalTime() <= now) &&
+            (v.ValidTo == null || v.ValidTo.Value.ToUniversalTime() > now)).ToList();
+
+        _logger.LogDebug("Category {TopicId}, Show {Show}: {AvailableCount} available out of {TotalCount} videos", topicId, show.Title, availableVideos.Count, videos.Count);
+
+        if (availableVideos.Count == 0)
+        {
+            _logger.LogDebug("Category {TopicId}, Show {Show}: No available videos (all expired or not yet published)", topicId, show.Title);
+            return null;
+        }
+
+        var latestVideo = availableVideos.OrderByDescending(v => v.Date).FirstOrDefault();
+        if (latestVideo?.Urn == null)
+        {
+            _logger.LogWarning("Category {TopicId}, Show {Show}: Latest available video has null URN", topicId, show.Title);
+            return null;
+        }
+
+        _logger.LogInformation(
+            "Category {TopicId}: Added video from show {Show}: {Title} (URN: {Urn}, Date: {Date})",
+            topicId,
+            show.Title,
+            latestVideo.Title,
+            latestVideo.Urn,
+            latestVideo.Date);
+
+        return latestVideo.Urn;
+    }
+
+    /// <inheritdoc />
+    public string? GetCacheKey(string? userId)
+    {
+        var config = Plugin.Instance?.Configuration;
+        var enabledTopics = config?.EnabledTopics != null && config.EnabledTopics.Count > 0
+            ? string.Join(",", config.EnabledTopics)
+            : "all";
+
+        // Use 15-minute time buckets for cache key so live content refreshes frequently
+        // This ensures livestream folders update as programs start/end throughout the day
+        var now = DateTime.Now;
+        var timeBucket = new DateTime(now.Year, now.Month, now.Day, now.Hour, (now.Minute / 15) * 15, 0);
+        var timeKey = timeBucket.ToString("yyyy-MM-dd-HH-mm", CultureInfo.InvariantCulture);
+
+        var recordingCount = _recordingService.GetRecordings(RecordingState.Completed).Count;
+        return $"{Unit}_{config?.EnableLatestContent}_{config?.EnableTrendingContent}_{config?.EnableCategoryFolders}_{enabledTopics}_{timeKey}_rec{recordingCount}";
+    }
+
+    private async Task<List<ChannelItemInfo>> ConvertUrnsToChannelItems(List<string> urns, CancellationToken cancellationToken)
+    {
+        var items = new List<ChannelItemInfo>();
+        var config = Plugin.Instance?.Configuration;
+
+        if (config == null)
+        {
+            _logger.LogWarning("Plugin configuration is null");
+            return items;
+        }
+
+        _logger.LogInformation("Converting {Count} URNs to channel items", urns.Count);
+
+        using var apiClient = _apiClientFactory.CreateClient();
+        int successCount = 0;
+        int failedCount = 0;
+        int expiredCount = 0;
+        int noStreamCount = 0;
+
+        foreach (var urn in urns.Take(50)) // Limit to 50 items per request
+        {
+            try
+            {
+                _logger.LogDebug("Processing URN: {Urn}", urn);
+                var mediaComposition = await apiClient.GetMediaCompositionByUrnAsync(urn, cancellationToken).ConfigureAwait(false);
+
+                if (mediaComposition?.HasChapters != true)
+                {
+                    _logger.LogWarning("URN {Urn}: No media composition or chapters found", urn);
+                    failedCount++;
+                    continue;
+                }
+
+                var chapter = mediaComposition.ChapterList[0];
+
+                // Check if content is expired
+                if (_streamResolver.IsContentExpired(chapter))
+                {
+                    _logger.LogDebug("URN {Urn}: Content expired (ValidTo: {ValidTo})", urn, chapter.ValidTo);
+                    expiredCount++;
+                    continue;
+                }
+
+                // Check if content has playable streams
+                if (!_streamResolver.HasPlayableContent(chapter))
+                {
+                    _logger.LogWarning("URN {Urn}: No playable content (likely DRM protected)", urn);
+                    noStreamCount++;
+                    continue;
+                }
+
+                // Generate deterministic GUID from URN
+                var itemId = UrnHelper.ToGuid(urn);
+
+                // Use factory to create MediaSourceInfo (handles stream URL, auth, proxy registration)
+                var mediaSource = await _mediaSourceFactory.CreateMediaSourceAsync(
+                    chapter,
+                    itemId,
+                    urn,
+                    config.QualityPreference,
+                    cancellationToken).ConfigureAwait(false);
+
+                // Skip items without a valid media source (no stream URL available)
+                if (mediaSource == null)
+                {
+                    if (chapter.Type == "SCHEDULED_LIVESTREAM")
+                    {
+                        _logger.LogDebug(
+                            "URN {Urn}: Skipping upcoming livestream '{Title}' - stream not yet available (starts at {ValidFrom})",
+                            urn,
+                            chapter.Title,
+                            chapter.ValidFrom);
+                    }
+                    else
+                    {
+                        _logger.LogWarning(
+                            "URN {Urn}: Skipping '{Title}' - no valid stream URL available",
+                            urn,
+                            chapter.Title);
+                        noStreamCount++;
+                    }
+
+                    continue;
+                }
+
+                // Build overview
+                var overview = chapter.Description ?? chapter.Lead;
+
+                // Determine image URL based on configuration
+                string? imageUrl;
+                var generateTitleCards = config.GenerateTitleCards;
+
+                if (generateTitleCards)
+                {
+                    // Generate title card with content name
+                    _logger.LogDebug("URN {Urn}: Generating title card for '{Title}'", urn, chapter.Title);
+                    imageUrl = CreatePlaceholderImageUrl(chapter.Title ?? "SRF Play", _mediaSourceFactory.GetServerBaseUrl());
+                }
+                else
+                {
+                    // Use SRF-provided images - prefer chapter image, fall back to show image
+                    var originalImageUrl = chapter.ImageUrl;
+                    if (string.IsNullOrEmpty(originalImageUrl) && mediaComposition.Show != null)
+                    {
+                        originalImageUrl = mediaComposition.Show.ImageUrl;
+                        _logger.LogDebug("URN {Urn}: Using show image as fallback", urn);
+                    }
+
+                    if (string.IsNullOrEmpty(originalImageUrl))
+                    {
+                        _logger.LogDebug("URN {Urn}: No image URL available for '{Title}', using placeholder", urn, chapter.Title);
+                        imageUrl = CreatePlaceholderImageUrl(chapter.Title ?? "SRF Play", _mediaSourceFactory.GetServerBaseUrl());
+                    }
+                    else
+                    {
+                        imageUrl = CreateProxiedImageUrl(originalImageUrl, _mediaSourceFactory.GetServerBaseUrl());
+                    }
+                }
+
+                // Use ValidFrom for premiere date if this is a scheduled livestream, otherwise use Date
+                var premiereDate = chapter.Type == "SCHEDULED_LIVESTREAM" ? chapter.ValidFrom?.ToUniversalTime() : chapter.Date?.ToUniversalTime();
+
+                // Store authenticated URL - tokens refresh automatically via scheduled channel scans
+                var item = new ChannelItemInfo
+                {
+                    Id = itemId,
+                    Name = chapter.Title,
+                    Overview = overview,
+                    ImageUrl = imageUrl,
+                    Type = ChannelItemType.Media,
+                    ContentType = ChannelMediaContentType.Episode,
+                    MediaType = ChannelMediaType.Video,
+                    DateCreated = chapter.Date?.ToUniversalTime(),
+                    PremiereDate = premiereDate,
+                    ProductionYear = chapter.Date?.Year,
+                    RunTimeTicks = chapter.Duration > 0 ? TimeSpan.FromMilliseconds(chapter.Duration).Ticks : null,
+                    ProviderIds = new Dictionary<string, string>
+                    {
+                        { "SRF", urn }
+                    }
+                };
+
+                // Add series info if available
+                if (mediaComposition.Show != null)
+                {
+                    item.SeriesName = mediaComposition.Show.Title;
+                }
+
+                items.Add(item);
+                successCount++;
+                _logger.LogInformation("URN {Urn}: Successfully converted to channel item - {Title}", urn, chapter.Title);
+                _logger.LogDebug(
+                    "URN {Urn}: MediaSource created via factory - DirectPlay={DirectPlay}, Transcoding={Transcoding}",
+                    urn,
+                    mediaSource.SupportsDirectPlay,
+                    mediaSource.SupportsTranscoding);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "Error converting URN {Urn} to channel item", urn);
+                failedCount++;
+            }
+        }
+
+        _logger.LogInformation(
+            "Conversion complete: {Success} successful, {Failed} failed, {Expired} expired, {NoStream} no stream",
+            successCount,
+            failedCount,
+            expiredCount,
+            noStreamCount);
+
+        return items;
+    }
+
+    /// <summary>
+    /// Creates a proxy URL for an image to fix Content-Type headers from SRF CDN.
+    /// </summary>
+    /// <param name="originalUrl">The original SRF image URL.</param>
+    /// <param name="serverUrl">The server base URL.</param>
+    /// <returns>The proxied image URL, or null if original is null.</returns>
+    private static string? CreateProxiedImageUrl(string? originalUrl, string serverUrl)
+    {
+        if (string.IsNullOrEmpty(originalUrl))
+        {
+            return null;
+        }
+
+        // Encode the original URL as base64 for safe transport
+        var encodedUrl = Convert.ToBase64String(Encoding.UTF8.GetBytes(originalUrl));
+        return $"{serverUrl}/Plugins/SRFPlay/Proxy/Image?url={encodedUrl}";
+    }
+
+    /// <summary>
+    /// Creates a placeholder image URL with the given text.
+    /// </summary>
+    /// <param name="text">The text to display on the placeholder.</param>
+    /// <param name="serverUrl">The server base URL.</param>
+    /// <returns>The placeholder image URL.</returns>
+    private static string CreatePlaceholderImageUrl(string text, string serverUrl)
+    {
+        var encodedText = Convert.ToBase64String(Encoding.UTF8.GetBytes(text));
+        return $"{serverUrl}/Plugins/SRFPlay/Proxy/Placeholder?text={encodedText}";
+    }
+
+    /// <inheritdoc />
+    public bool IsEnabledFor(string userId)
+    {
+        return true;
+    }
+}

Jellyfin.Plugin.SRFPlay/Channels/SwiChannel.cs

@@ -0,0 +1,43 @@
+using Jellyfin.Plugin.SRFPlay.Api;
+using Jellyfin.Plugin.SRFPlay.Configuration;
+using Jellyfin.Plugin.SRFPlay.Services.Interfaces;
+using Microsoft.Extensions.Logging;
+
+namespace Jellyfin.Plugin.SRFPlay.Channels;
+
+/// <summary>
+/// SWI swissinfo.ch — Swiss international channel.
+/// </summary>
+public sealed class SwiChannel : SrgChannelBase
+{
+    /// <summary>
+    /// Initializes a new instance of the <see cref="SwiChannel"/> class.
+    /// </summary>
+    /// <param name="loggerFactory">The logger factory.</param>
+    /// <param name="contentRefreshService">The content refresh service.</param>
+    /// <param name="streamResolver">The stream resolver.</param>
+    /// <param name="mediaSourceFactory">The media source factory.</param>
+    /// <param name="categoryService">The category service.</param>
+    /// <param name="apiClientFactory">The API client factory.</param>
+    /// <param name="recordingService">The recording service.</param>
+    public SwiChannel(
+        ILoggerFactory loggerFactory,
+        IContentRefreshService contentRefreshService,
+        IStreamUrlResolver streamResolver,
+        IMediaSourceFactory mediaSourceFactory,
+        ICategoryService? categoryService,
+        ISRFApiClientFactory apiClientFactory,
+        IRecordingService recordingService)
+        : base(loggerFactory, contentRefreshService, streamResolver, mediaSourceFactory, categoryService, apiClientFactory, recordingService)
+    {
+    }
+
+    /// <inheritdoc />
+    protected override BusinessUnit Unit => BusinessUnit.SWI;
+
+    /// <inheritdoc />
+    protected override string LogoResourceName => "Jellyfin.Plugin.SRFPlay.Images.swi-logo.png";
+
+    /// <inheritdoc />
+    public override string Description => "SWI swissinfo.ch — Swiss international video-on-demand content";
+}

Jellyfin.Plugin.SRFPlay/Configuration/PluginConfiguration.cs

@@ -0,0 +1,214 @@
+using MediaBrowser.Model.Plugins;
+
+namespace Jellyfin.Plugin.SRFPlay.Configuration;
+
+/// <summary>
+/// Business unit options for SRF content.
+/// </summary>
+public enum BusinessUnit
+{
+    /// <summary>
+    /// SRF (Swiss Radio and Television - German).
+    /// </summary>
+    SRF,
+
+    /// <summary>
+    /// RTS (Radio Télévision Suisse - French).
+    /// </summary>
+    RTS,
+
+    /// <summary>
+    /// RSI (Radiotelevisione svizzera - Italian).
+    /// </summary>
+    RSI,
+
+    /// <summary>
+    /// RTR (Radiotelevisiun Svizra Rumantscha - Romansh).
+    /// </summary>
+    RTR,
+
+    /// <summary>
+    /// SWI (Swiss World International).
+    /// </summary>
+    SWI
+}
+
+/// <summary>
+/// Quality preference for video streams.
+/// </summary>
+public enum QualityPreference
+{
+    /// <summary>
+    /// Automatic quality selection.
+    /// </summary>
+    Auto,
+
+    /// <summary>
+    /// Standard definition.
+    /// </summary>
+    SD,
+
+    /// <summary>
+    /// High definition.
+    /// </summary>
+    HD
+}
+
+/// <summary>
+/// Plugin configuration.
+/// </summary>
+public class PluginConfiguration : BasePluginConfiguration
+{
+    /// <summary>
+    /// Initializes a new instance of the <see cref="PluginConfiguration"/> class.
+    /// </summary>
+    public PluginConfiguration()
+    {
+        // Set default options
+        BusinessUnit = BusinessUnit.SRF;
+        QualityPreference = QualityPreference.Auto;
+        ContentRefreshIntervalHours = 6;
+        ExpirationCheckIntervalHours = 24;
+        CacheDurationMinutes = 60;
+        EnableLatestContent = true;
+        EnableTrendingContent = true;
+        EnableCategoryFolders = true;
+        EnabledTopics = new System.Collections.Generic.List<string>();
+        GenerateTitleCards = true;
+        LiveStartSegmentsBack = 3;
+        CleanUpResumePoints = true;
+        ClearLiveStreamResumePoints = true;
+        ResumePointMaxAgeDays = 30;
+        ResumePointMinPositionSeconds = 60;
+        ResumePointCompletedPercent = 92;
+    }
+
+    /// <summary>
+    /// Gets or sets the legacy single business unit. Retained only for backwards compatibility
+    /// with older configs; every unit now has its own always-on channel.
+    /// </summary>
+    public BusinessUnit BusinessUnit { get; set; }
+
+    /// <summary>
+    /// Gets or sets the preferred video quality.
+    /// </summary>
+    public QualityPreference QualityPreference { get; set; }
+
+    /// <summary>
+    /// Gets or sets the content refresh interval in hours.
+    /// </summary>
+    public int ContentRefreshIntervalHours { get; set; }
+
+    /// <summary>
+    /// Gets or sets the expiration check interval in hours.
+    /// </summary>
+    public int ExpirationCheckIntervalHours { get; set; }
+
+    /// <summary>
+    /// Gets or sets the metadata cache duration in minutes.
+    /// </summary>
+    public int CacheDurationMinutes { get; set; }
+
+    /// <summary>
+    /// Gets or sets a value indicating whether to enable latest content discovery.
+    /// </summary>
+    public bool EnableLatestContent { get; set; }
+
+    /// <summary>
+    /// Gets or sets a value indicating whether to enable trending content discovery.
+    /// </summary>
+    public bool EnableTrendingContent { get; set; }
+
+    /// <summary>
+    /// Gets or sets a value indicating whether to use a proxy for API requests.
+    /// </summary>
+    public bool UseProxy { get; set; }
+
+    /// <summary>
+    /// Gets or sets the proxy server address (e.g., http://proxy.example.com:8080).
+    /// </summary>
+    public string ProxyAddress { get; set; } = string.Empty;
+
+    /// <summary>
+    /// Gets or sets the proxy username (optional).
+    /// </summary>
+    public string ProxyUsername { get; set; } = string.Empty;
+
+    /// <summary>
+    /// Gets or sets the proxy password (optional).
+    /// </summary>
+    public string ProxyPassword { get; set; } = string.Empty;
+
+    /// <summary>
+    /// Gets or sets a value indicating whether to enable category/topic folders in the channel.
+    /// </summary>
+    public bool EnableCategoryFolders { get; set; }
+
+    /// <summary>
+    /// Gets or sets the list of enabled topic IDs. If empty, all topics are shown.
+    /// </summary>
+    [System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2227:Collection properties should be read only", Justification = "Required for configuration serialization")]
+    [System.Diagnostics.CodeAnalysis.SuppressMessage("Design", "CA1002:Do not expose generic lists", Justification = "Configuration DTO")]
+    public System.Collections.Generic.List<string> EnabledTopics { get; set; }
+
+    /// <summary>
+    /// Gets or sets the public/external server URL for remote clients (e.g., https://jellyfin.example.com:8920).
+    /// If not set, the plugin will use Jellyfin's GetSmartApiUrl() which may return local addresses.
+    /// This is important for Android and other remote clients to access streams.
+    /// </summary>
+    public string PublicServerUrl { get; set; } = string.Empty;
+
+    /// <summary>
+    /// Gets or sets a value indicating whether to generate title card images with the content title.
+    /// When enabled, generates custom thumbnails instead of using SRF-provided images.
+    /// </summary>
+    public bool GenerateTitleCards { get; set; }
+
+    /// <summary>
+    /// Gets or sets the output directory for sport livestream recordings.
+    /// </summary>
+    public string RecordingOutputPath { get; set; } = string.Empty;
+
+    /// <summary>
+    /// Gets or sets how many segments back from the live edge livestream playback should start.
+    /// Injected as <c>#EXT-X-START:TIME-OFFSET=-(N * targetDuration)</c> into the live media
+    /// playlist. This keeps the start point out of the volatile live edge, which on Android TV
+    /// (ExoPlayer) otherwise causes stalling/jumping until a manual skip. RFC 8216 requires the
+    /// offset to stay at least 3 target durations from the edge, so values below 3 are clamped.
+    /// Set to 0 to disable injection entirely.
+    /// </summary>
+    public int LiveStartSegmentsBack { get; set; }
+
+    /// <summary>
+    /// Gets or sets a value indicating whether the "Clean Up SRF Play Continue Watching" task
+    /// removes stale resume points. When false the task inspects nothing and clears nothing.
+    /// </summary>
+    public bool CleanUpResumePoints { get; set; }
+
+    /// <summary>
+    /// Gets or sets a value indicating whether resume points for livestreams are cleared.
+    /// A livestream has no meaningful resume position, so stopping one otherwise leaves it
+    /// pinned in "Continue Watching" forever. When enabled the position is also cleared
+    /// immediately on playback stop, not just by the scheduled task.
+    /// </summary>
+    public bool ClearLiveStreamResumePoints { get; set; }
+
+    /// <summary>
+    /// Gets or sets the age in days after which an untouched resume point is cleared.
+    /// Measured from the last time the item was played. Set to 0 to disable the age rule.
+    /// </summary>
+    public int ResumePointMaxAgeDays { get; set; }
+
+    /// <summary>
+    /// Gets or sets the minimum resume position in seconds. Anything at or below this is
+    /// treated as an accidental start rather than something worth resuming.
+    /// Set to 0 to disable the rule.
+    /// </summary>
+    public int ResumePointMinPositionSeconds { get; set; }
+
+    /// <summary>
+    /// Gets or sets the percentage of runtime at or beyond which playback counts as finished.
+    /// Only applied to items with a known runtime. Set to 0 to disable the rule.
+    /// </summary>
+    public int ResumePointCompletedPercent { get; set; }
+}

Jellyfin.Plugin.SRFPlay/Configuration/configPage.html

@@ -0,0 +1,482 @@
+<div id="SRFPlayConfigPage" data-role="page" class="page type-interior pluginConfigurationPage" data-require="emby-input,emby-button,emby-select,emby-checkbox">
+        <div data-role="content">
+            <div class="content-primary">
+                <form id="SRFPlayConfigForm">
+                    <div class="checkboxContainer checkboxContainer-withDescription">
+                        <h3>Channels</h3>
+                        <div class="fieldDescription">Every Swiss broadcaster has its own channel tile: SRF (German), RTS (French), RSI (Italian), RTR (Romansh) and SWI (swissinfo.ch). They are always available — pin the ones you use from the Jellyfin home screen.</div>
+                    </div>
+                    <div class="selectContainer">
+                        <label class="selectLabel" for="QualityPreference">Quality Preference</label>
+                        <select is="emby-select" id="QualityPreference" name="QualityPreference" class="emby-select-withcolor emby-select">
+                            <option id="optAuto" value="Auto">Automatic</option>
+                            <option id="optSD" value="SD">Standard Definition</option>
+                            <option id="optHD" value="HD">High Definition</option>
+                        </select>
+                        <div class="fieldDescription">Preferred video quality for playback</div>
+                    </div>
+                    <div class="inputContainer">
+                        <label class="inputLabel inputLabelUnfocused" for="ContentRefreshIntervalHours">Content Refresh Interval (hours)</label>
+                        <input id="ContentRefreshIntervalHours" name="ContentRefreshIntervalHours" type="number" is="emby-input" min="1" max="168" />
+                        <div class="fieldDescription">How often to check for new content (1-168 hours)</div>
+                    </div>
+                    <div class="inputContainer">
+                        <label class="inputLabel inputLabelUnfocused" for="ExpirationCheckIntervalHours">Expiration Check Interval (hours)</label>
+                        <input id="ExpirationCheckIntervalHours" name="ExpirationCheckIntervalHours" type="number" is="emby-input" min="1" max="168" />
+                        <div class="fieldDescription">How often to check for expired content (1-168 hours)</div>
+                    </div>
+                    <div class="inputContainer">
+                        <label class="inputLabel inputLabelUnfocused" for="CacheDurationMinutes">Cache Duration (minutes)</label>
+                        <input id="CacheDurationMinutes" name="CacheDurationMinutes" type="number" is="emby-input" min="5" max="1440" />
+                        <div class="fieldDescription">How long to cache metadata (5-1440 minutes)</div>
+                    </div>
+                    <div class="checkboxContainer checkboxContainer-withDescription">
+                        <label class="emby-checkbox-label">
+                            <input id="EnableLatestContent" name="EnableLatestContent" type="checkbox" is="emby-checkbox" />
+                            <span>Enable Latest Content</span>
+                        </label>
+                        <div class="fieldDescription">Automatically discover and add latest videos</div>
+                    </div>
+                    <div class="checkboxContainer checkboxContainer-withDescription">
+                        <label class="emby-checkbox-label">
+                            <input id="EnableTrendingContent" name="EnableTrendingContent" type="checkbox" is="emby-checkbox" />
+                            <span>Enable Trending Content</span>
+                        </label>
+                        <div class="fieldDescription">Automatically discover and add trending videos</div>
+                    </div>
+                    <div class="checkboxContainer checkboxContainer-withDescription">
+                        <label class="emby-checkbox-label">
+                            <input id="GenerateTitleCards" name="GenerateTitleCards" type="checkbox" is="emby-checkbox" />
+                            <span>Generate Title Cards</span>
+                        </label>
+                        <div class="fieldDescription">Generate custom thumbnails with the content title instead of using SRF-provided images</div>
+                    </div>
+                    <br />
+                    <h2>Proxy Settings</h2>
+                    <div class="checkboxContainer checkboxContainer-withDescription">
+                        <label class="emby-checkbox-label">
+                            <input id="UseProxy" name="UseProxy" type="checkbox" is="emby-checkbox" />
+                            <span>Use Proxy</span>
+                        </label>
+                        <div class="fieldDescription">Route all SRF API requests through a proxy server</div>
+                    </div>
+                    <div class="inputContainer">
+                        <label class="inputLabel inputLabelUnfocused" for="ProxyAddress">Proxy Address</label>
+                        <input id="ProxyAddress" name="ProxyAddress" type="text" is="emby-input" />
+                        <div class="fieldDescription">Proxy server address (e.g., http://proxy.example.com:8080 or socks5://proxy.example.com:1080)</div>
+                    </div>
+                    <div class="inputContainer">
+                        <label class="inputLabel inputLabelUnfocused" for="ProxyUsername">Proxy Username (Optional)</label>
+                        <input id="ProxyUsername" name="ProxyUsername" type="text" is="emby-input" autocomplete="off" />
+                        <div class="fieldDescription">Username for proxy authentication (leave empty if not required)</div>
+                    </div>
+                    <div class="inputContainer">
+                        <label class="inputLabel inputLabelUnfocused" for="ProxyPassword">Proxy Password (Optional)</label>
+                        <input id="ProxyPassword" name="ProxyPassword" type="password" is="emby-input" autocomplete="off" />
+                        <div class="fieldDescription">Password for proxy authentication (leave empty if not required)</div>
+                    </div>
+                    <br />
+                    <h2>Recording Settings</h2>
+                    <div class="inputContainer">
+                        <label class="inputLabel inputLabelUnfocused" for="RecordingOutputPath">Recording Output Directory</label>
+                        <input id="RecordingOutputPath" name="RecordingOutputPath" type="text" is="emby-input" placeholder="e.g., /media/recordings/srf" />
+                        <div class="fieldDescription">Directory where sport livestream recordings will be saved (requires ffmpeg)</div>
+                    </div>
+                    <div class="inputContainer">
+                        <label class="inputLabel inputLabelUnfocused" for="LiveStartSegmentsBack">Live Start Offset (segments)</label>
+                        <input id="LiveStartSegmentsBack" name="LiveStartSegmentsBack" type="number" is="emby-input" min="0" max="20" />
+                        <div class="fieldDescription">How many segments back from the live edge livestreams start playing. Fixes jumpy/stalling playback at the start on Android TV. Minimum 3 (RFC requirement); 0 disables it. Default 3.</div>
+                    </div>
+                    <br />
+                    <h2>Continue Watching Cleanup</h2>
+                    <div class="fieldDescription" style="margin-bottom: 1em;">
+                        Livestreams and abandoned playback otherwise stay pinned in every user's
+                        &quot;Continue Watching&quot; row forever. Clearing a resume point only resets the
+                        playback position &mdash; nothing is deleted and the item stays unwatched.
+                    </div>
+                    <div class="checkboxContainer checkboxContainer-withDescription">
+                        <label class="emby-checkbox-label">
+                            <input id="CleanUpResumePoints" name="CleanUpResumePoints" type="checkbox" is="emby-checkbox" />
+                            <span>Clean up stale resume points</span>
+                        </label>
+                        <div class="fieldDescription checkboxFieldDescription">Runs daily at 4 AM (Scheduled Tasks &rarr; &quot;Clean Up SRF Play Continue Watching&quot;)</div>
+                    </div>
+                    <div class="checkboxContainer checkboxContainer-withDescription">
+                        <label class="emby-checkbox-label">
+                            <input id="ClearLiveStreamResumePoints" name="ClearLiveStreamResumePoints" type="checkbox" is="emby-checkbox" />
+                            <span>Never keep a resume point for livestreams</span>
+                        </label>
+                        <div class="fieldDescription checkboxFieldDescription">Clears the position as soon as a livestream stops playing, rather than waiting for the daily task</div>
+                    </div>
+                    <div class="inputContainer">
+                        <label class="inputLabel inputLabelUnfocused" for="ResumePointMaxAgeDays">Maximum Resume Point Age (days)</label>
+                        <input id="ResumePointMaxAgeDays" name="ResumePointMaxAgeDays" type="number" is="emby-input" min="0" max="3650" />
+                        <div class="fieldDescription">Clear resume points not touched for this many days. 0 disables the rule. Default 30.</div>
+                    </div>
+                    <div class="inputContainer">
+                        <label class="inputLabel inputLabelUnfocused" for="ResumePointMinPositionSeconds">Minimum Resume Position (seconds)</label>
+                        <input id="ResumePointMinPositionSeconds" name="ResumePointMinPositionSeconds" type="number" is="emby-input" min="0" max="3600" />
+                        <div class="fieldDescription">Positions at or below this are treated as an accidental start and cleared. 0 disables the rule. Default 60.</div>
+                    </div>
+                    <div class="inputContainer">
+                        <label class="inputLabel inputLabelUnfocused" for="ResumePointCompletedPercent">Finished Threshold (%)</label>
+                        <input id="ResumePointCompletedPercent" name="ResumePointCompletedPercent" type="number" is="emby-input" min="0" max="100" />
+                        <div class="fieldDescription">Playback at or beyond this share of the runtime counts as finished. Only applies when the runtime is known. 0 disables the rule. Default 92.</div>
+                    </div>
+                    <br />
+                    <h2>Network Settings</h2>
+                    <div class="inputContainer">
+                        <label class="inputLabel inputLabelUnfocused" for="PublicServerUrl">Public Server URL (Optional)</label>
+                        <input id="PublicServerUrl" name="PublicServerUrl" type="text" is="emby-input" placeholder="e.g., https://jellyfin.example.com:8920" />
+                        <div class="fieldDescription">
+                            The public/external URL for remote clients (Android, iOS, etc.) to access streaming proxy.
+                            <br />If not set, the plugin will use Jellyfin's automatic URL detection which may return local addresses.
+                            <br /><strong>Important for Android/remote playback!</strong>
+                        </div>
+                    </div>
+                    <div>
+                        <button is="emby-button" type="submit" class="raised button-submit block emby-button">
+                            <span>Save</span>
+                        </button>
+                    </div>
+                </form>
+
+                <br />
+                <h2>Continue Watching Maintenance</h2>
+                <div class="fieldDescription">Run the cleanup right now instead of waiting for the daily task. Only SRF Play items are affected.</div>
+                <div id="resumeCleanupResult" style="margin: 10px 0;"></div>
+                <button is="emby-button" type="button" class="raised emby-button" onclick="SRFPlayMaintenance.cleanupResumePoints(false)" style="margin-bottom: 20px;">
+                    <span>Clean Up Stale Entries Now</span>
+                </button>
+                <button is="emby-button" type="button" class="raised emby-button" onclick="SRFPlayMaintenance.cleanupResumePoints(true)" style="margin-bottom: 20px;">
+                    <span>Clear All SRF Play Entries</span>
+                </button>
+
+                <br />
+                <h2>Sport Livestream Recordings</h2>
+
+                <h3>Upcoming Sport Livestreams</h3>
+                <div class="fieldDescription">Select livestreams to record. The recording starts automatically when the stream goes live.</div>
+                <div id="scheduleContainer" style="margin: 10px 0;">
+                    <p><em>Loading schedule...</em></p>
+                </div>
+                <button is="emby-button" type="button" class="raised emby-button" onclick="SRFPlayRecordings.loadSchedule()" style="margin-bottom: 20px;">
+                    <span>Refresh Schedule</span>
+                </button>
+
+                <h3>Scheduled &amp; Active Recordings</h3>
+                <div id="activeRecordingsContainer" style="margin: 10px 0;">
+                    <p><em>Loading...</em></p>
+                </div>
+
+                <h3>Completed Recordings</h3>
+                <div id="completedRecordingsContainer" style="margin: 10px 0;">
+                    <p><em>Loading...</em></p>
+                </div>
+                <button is="emby-button" type="button" class="raised emby-button" onclick="SRFPlayRecordings.loadRecordings()" style="margin-bottom: 20px;">
+                    <span>Refresh Recordings</span>
+                </button>
+            </div>
+        </div>
+        <script type="text/javascript">
+            var SRFPlayConfig = {
+                pluginUniqueId: 'a4b12f86-8c3d-4e9a-b7f2-1d5e6c8a9b4f'
+            };
+
+            document.querySelector('#SRFPlayConfigPage')
+                .addEventListener('pageshow', function() {
+                    Dashboard.showLoadingMsg();
+                    ApiClient.getPluginConfiguration(SRFPlayConfig.pluginUniqueId).then(function (config) {
+                        document.querySelector('#QualityPreference').value = config.QualityPreference;
+                        document.querySelector('#ContentRefreshIntervalHours').value = config.ContentRefreshIntervalHours;
+                        document.querySelector('#ExpirationCheckIntervalHours').value = config.ExpirationCheckIntervalHours;
+                        document.querySelector('#CacheDurationMinutes').value = config.CacheDurationMinutes;
+                        document.querySelector('#EnableLatestContent').checked = config.EnableLatestContent;
+                        document.querySelector('#EnableTrendingContent').checked = config.EnableTrendingContent;
+                        document.querySelector('#GenerateTitleCards').checked = config.GenerateTitleCards !== false;
+                        document.querySelector('#UseProxy').checked = config.UseProxy || false;
+                        document.querySelector('#ProxyAddress').value = config.ProxyAddress || '';
+                        document.querySelector('#ProxyUsername').value = config.ProxyUsername || '';
+                        document.querySelector('#ProxyPassword').value = config.ProxyPassword || '';
+                        document.querySelector('#PublicServerUrl').value = config.PublicServerUrl || '';
+                        document.querySelector('#RecordingOutputPath').value = config.RecordingOutputPath || '';
+                        document.querySelector('#LiveStartSegmentsBack').value = config.LiveStartSegmentsBack != null ? config.LiveStartSegmentsBack : 3;
+                        document.querySelector('#CleanUpResumePoints').checked = config.CleanUpResumePoints !== false;
+                        document.querySelector('#ClearLiveStreamResumePoints').checked = config.ClearLiveStreamResumePoints !== false;
+                        document.querySelector('#ResumePointMaxAgeDays').value = config.ResumePointMaxAgeDays != null ? config.ResumePointMaxAgeDays : 30;
+                        document.querySelector('#ResumePointMinPositionSeconds').value = config.ResumePointMinPositionSeconds != null ? config.ResumePointMinPositionSeconds : 60;
+                        document.querySelector('#ResumePointCompletedPercent').value = config.ResumePointCompletedPercent != null ? config.ResumePointCompletedPercent : 92;
+                        Dashboard.hideLoadingMsg();
+
+                        // Load recordings UI
+                        SRFPlayRecordings.loadSchedule();
+                        SRFPlayRecordings.loadRecordings();
+                    });
+                });
+
+            document.querySelector('#SRFPlayConfigForm')
+                .addEventListener('submit', function(e) {
+                Dashboard.showLoadingMsg();
+                ApiClient.getPluginConfiguration(SRFPlayConfig.pluginUniqueId).then(function (config) {
+                    config.QualityPreference = document.querySelector('#QualityPreference').value;
+                    config.ContentRefreshIntervalHours = parseInt(document.querySelector('#ContentRefreshIntervalHours').value);
+                    config.ExpirationCheckIntervalHours = parseInt(document.querySelector('#ExpirationCheckIntervalHours').value);
+                    config.CacheDurationMinutes = parseInt(document.querySelector('#CacheDurationMinutes').value);
+                    config.EnableLatestContent = document.querySelector('#EnableLatestContent').checked;
+                    config.EnableTrendingContent = document.querySelector('#EnableTrendingContent').checked;
+                    config.GenerateTitleCards = document.querySelector('#GenerateTitleCards').checked;
+                    config.UseProxy = document.querySelector('#UseProxy').checked;
+                    config.ProxyAddress = document.querySelector('#ProxyAddress').value;
+                    config.ProxyUsername = document.querySelector('#ProxyUsername').value;
+                    config.ProxyPassword = document.querySelector('#ProxyPassword').value;
+                    config.PublicServerUrl = document.querySelector('#PublicServerUrl').value;
+                    config.RecordingOutputPath = document.querySelector('#RecordingOutputPath').value;
+                    config.LiveStartSegmentsBack = parseInt(document.querySelector('#LiveStartSegmentsBack').value) || 0;
+                    config.CleanUpResumePoints = document.querySelector('#CleanUpResumePoints').checked;
+                    config.ClearLiveStreamResumePoints = document.querySelector('#ClearLiveStreamResumePoints').checked;
+                    config.ResumePointMaxAgeDays = parseInt(document.querySelector('#ResumePointMaxAgeDays').value) || 0;
+                    config.ResumePointMinPositionSeconds = parseInt(document.querySelector('#ResumePointMinPositionSeconds').value) || 0;
+                    config.ResumePointCompletedPercent = parseInt(document.querySelector('#ResumePointCompletedPercent').value) || 0;
+                    ApiClient.updatePluginConfiguration(SRFPlayConfig.pluginUniqueId, config).then(function (result) {
+                        Dashboard.processPluginConfigurationUpdateResult(result);
+                    });
+                });
+
+                e.preventDefault();
+                return false;
+            });
+
+            var SRFPlayMaintenance = {
+                cleanupResumePoints: function(clearAll) {
+                    if (clearAll && !confirm('Clear the playback position of every SRF Play item for all users? Nothing is deleted and items stay unwatched.')) {
+                        return;
+                    }
+
+                    var target = document.querySelector('#resumeCleanupResult');
+                    target.innerHTML = '<p><em>Cleaning up...</em></p>';
+
+                    fetch(ApiClient.serverAddress() + '/Plugins/SRFPlay/Maintenance/ResumePoints/Cleanup?clearAll=' + (clearAll ? 'true' : 'false'), {
+                        method: 'POST',
+                        headers: { 'X-Emby-Token': ApiClient.accessToken() }
+                    })
+                    .then(function(response) {
+                        if (!response.ok) {
+                            throw new Error('HTTP ' + response.status);
+                        }
+                        return response.json();
+                    })
+                    .then(function(result) {
+                        var byReason = result.clearedByReason || {};
+                        var reasons = Object.keys(byReason)
+                            .map(function(key) { return key + ': ' + byReason[key]; })
+                            .join(', ');
+                        target.innerHTML = '<p>Cleared <strong>' + result.cleared + '</strong> of ' + result.inspected +
+                            ' SRF Play resume point(s) across ' + result.usersChecked + ' user(s).' +
+                            (reasons ? ' (' + reasons + ')' : '') + '</p>';
+                    })
+                    .catch(function(error) {
+                        target.innerHTML = '<p style="color: #d44;">Cleanup failed: ' + error.message + '</p>';
+                    });
+                }
+            };
+
+            var SRFPlayRecordings = {
+                apiBase: ApiClient.serverAddress() + '/Plugins/SRFPlay/Recording',
+
+                getHeaders: function() {
+                    return {
+                        'X-Emby-Token': ApiClient.accessToken()
+                    };
+                },
+
+                formatDate: function(dateStr) {
+                    if (!dateStr) return 'N/A';
+                    var d = new Date(dateStr);
+                    return d.toLocaleDateString() + ' ' + d.toLocaleTimeString([], {hour: '2-digit', minute:'2-digit'});
+                },
+
+                formatSize: function(bytes) {
+                    if (!bytes) return '';
+                    if (bytes > 1073741824) return (bytes / 1073741824).toFixed(1) + ' GB';
+                    if (bytes > 1048576) return (bytes / 1048576).toFixed(0) + ' MB';
+                    return (bytes / 1024).toFixed(0) + ' KB';
+                },
+
+                loadSchedule: function() {
+                    var container = document.getElementById('scheduleContainer');
+                    container.innerHTML = '<p><em>Loading schedule...</em></p>';
+
+                    fetch(this.apiBase + '/Schedule', { headers: this.getHeaders() })
+                        .then(function(r) { return r.json(); })
+                        .then(function(programs) {
+                            if (!programs || programs.length === 0) {
+                                container.innerHTML = '<p>No upcoming sport livestreams found.</p>';
+                                return;
+                            }
+
+                            var html = '<table style="width:100%; border-collapse: collapse;">';
+                            html += '<thead><tr style="text-align:left; border-bottom: 1px solid #444;">';
+                            html += '<th style="padding: 8px;">Title</th>';
+                            html += '<th style="padding: 8px;">Start</th>';
+                            html += '<th style="padding: 8px;">End</th>';
+                            html += '<th style="padding: 8px;">Action</th>';
+                            html += '</tr></thead><tbody>';
+
+                            programs.forEach(function(p) {
+                                html += '<tr style="border-bottom: 1px solid #333;">';
+                                html += '<td style="padding: 8px;">' + (p.title || 'Unknown') + '</td>';
+                                html += '<td style="padding: 8px;">' + SRFPlayRecordings.formatDate(p.validFrom || p.date) + '</td>';
+                                html += '<td style="padding: 8px;">' + SRFPlayRecordings.formatDate(p.validTo) + '</td>';
+                                html += '<td style="padding: 8px;">';
+                                html += '<button is="emby-button" type="button" class="raised emby-button" ';
+                                html += 'onclick="SRFPlayRecordings.scheduleRecording(\'' + encodeURIComponent(p.urn) + '\')">';
+                                html += '<span>Record</span></button>';
+                                html += '</td></tr>';
+                            });
+
+                            html += '</tbody></table>';
+                            container.innerHTML = html;
+                        })
+                        .catch(function(err) {
+                            container.innerHTML = '<p style="color: #f44;">Error loading schedule: ' + err.message + '</p>';
+                        });
+                },
+
+                scheduleRecording: function(encodedUrn) {
+                    fetch(this.apiBase + '/Schedule/' + encodedUrn, {
+                        method: 'POST',
+                        headers: this.getHeaders()
+                    })
+                    .then(function(r) {
+                        if (r.ok) {
+                            Dashboard.alert('Recording scheduled!');
+                            SRFPlayRecordings.loadRecordings();
+                        } else {
+                            Dashboard.alert('Failed to schedule recording');
+                        }
+                    })
+                    .catch(function(err) { Dashboard.alert('Error: ' + err.message); });
+                },
+
+                loadRecordings: function() {
+                    this.loadActiveRecordings();
+                    this.loadCompletedRecordings();
+                },
+
+                loadActiveRecordings: function() {
+                    var container = document.getElementById('activeRecordingsContainer');
+                    container.innerHTML = '<p><em>Loading...</em></p>';
+
+                    fetch(this.apiBase + '/All', { headers: this.getHeaders() })
+                        .then(function(r) { return r.json(); })
+                        .then(function(recordings) {
+                            var activeStates = ['Scheduled', 'WaitingForStream', 'Recording', 0, 1, 2];
+                            var active = recordings.filter(function(r) {
+                                return activeStates.indexOf(r.state) !== -1;
+                            });
+
+                            if (active.length === 0) {
+                                container.innerHTML = '<p>No scheduled or active recordings.</p>';
+                                return;
+                            }
+
+                            var stateLabels = {'Scheduled': 'Scheduled', 'WaitingForStream': 'Waiting', 'Recording': 'Recording', 'Completed': 'Completed', 'Failed': 'Failed', 'Cancelled': 'Cancelled', 0: 'Scheduled', 1: 'Waiting', 2: 'Recording', 3: 'Completed', 4: 'Failed', 5: 'Cancelled'};
+                            var stateColors = {'Scheduled': '#2196F3', 'WaitingForStream': '#FF9800', 'Recording': '#4CAF50', 'Failed': '#f44336', 'Cancelled': '#9E9E9E', 0: '#2196F3', 1: '#FF9800', 2: '#4CAF50', 4: '#f44336', 5: '#9E9E9E'};
+
+                            var html = '<table style="width:100%; border-collapse: collapse;">';
+                            html += '<thead><tr style="text-align:left; border-bottom: 1px solid #444;">';
+                            html += '<th style="padding: 8px;">Title</th>';
+                            html += '<th style="padding: 8px;">Status</th>';
+                            html += '<th style="padding: 8px;">Start</th>';
+                            html += '<th style="padding: 8px;">Action</th>';
+                            html += '</tr></thead><tbody>';
+
+                            active.forEach(function(r) {
+                                html += '<tr style="border-bottom: 1px solid #333;">';
+                                html += '<td style="padding: 8px;">' + (r.title || 'Unknown') + '</td>';
+                                html += '<td style="padding: 8px;"><span style="color:' + (stateColors[r.state] || '#fff') + ';">' + (stateLabels[r.state] || r.state) + '</span></td>';
+                                html += '<td style="padding: 8px;">' + SRFPlayRecordings.formatDate(r.validFrom) + '</td>';
+                                html += '<td style="padding: 8px;">';
+                                if (r.state === 2 || r.state === 'Recording') {
+                                    html += '<button is="emby-button" type="button" class="raised emby-button" ';
+                                    html += 'onclick="SRFPlayRecordings.stopRecording(\'' + r.id + '\')"><span>Stop</span></button>';
+                                } else {
+                                    html += '<button is="emby-button" type="button" class="raised emby-button" ';
+                                    html += 'onclick="SRFPlayRecordings.cancelRecording(\'' + r.id + '\')"><span>Cancel</span></button>';
+                                }
+                                html += '</td></tr>';
+                            });
+
+                            html += '</tbody></table>';
+                            container.innerHTML = html;
+                        })
+                        .catch(function(err) {
+                            container.innerHTML = '<p style="color: #f44;">Error: ' + err.message + '</p>';
+                        });
+                },
+
+                loadCompletedRecordings: function() {
+                    var container = document.getElementById('completedRecordingsContainer');
+                    container.innerHTML = '<p><em>Loading...</em></p>';
+
+                    fetch(this.apiBase + '/Completed', { headers: this.getHeaders() })
+                        .then(function(r) { return r.json(); })
+                        .then(function(recordings) {
+                            if (!recordings || recordings.length === 0) {
+                                container.innerHTML = '<p>No completed recordings.</p>';
+                                return;
+                            }
+
+                            var html = '<table style="width:100%; border-collapse: collapse;">';
+                            html += '<thead><tr style="text-align:left; border-bottom: 1px solid #444;">';
+                            html += '<th style="padding: 8px;">Title</th>';
+                            html += '<th style="padding: 8px;">Recorded</th>';
+                            html += '<th style="padding: 8px;">Size</th>';
+                            html += '<th style="padding: 8px;">File</th>';
+                            html += '<th style="padding: 8px;">Action</th>';
+                            html += '</tr></thead><tbody>';
+
+                            recordings.forEach(function(r) {
+                                html += '<tr style="border-bottom: 1px solid #333;">';
+                                html += '<td style="padding: 8px;">' + (r.title || 'Unknown') + '</td>';
+                                html += '<td style="padding: 8px;">' + SRFPlayRecordings.formatDate(r.recordingStartedAt) + '</td>';
+                                html += '<td style="padding: 8px;">' + SRFPlayRecordings.formatSize(r.fileSizeBytes) + '</td>';
+                                html += '<td style="padding: 8px; font-size: 0.85em; word-break: break-all;">' + (r.outputPath || '') + '</td>';
+                                html += '<td style="padding: 8px;">';
+                                html += '<button is="emby-button" type="button" class="raised emby-button" style="background:#f44336;" ';
+                                html += 'onclick="SRFPlayRecordings.deleteRecording(\'' + r.id + '\')"><span>Delete</span></button>';
+                                html += '</td></tr>';
+                            });
+
+                            html += '</tbody></table>';
+                            container.innerHTML = html;
+                        })
+                        .catch(function(err) {
+                            container.innerHTML = '<p style="color: #f44;">Error: ' + err.message + '</p>';
+                        });
+                },
+
+                stopRecording: function(id) {
+                    fetch(this.apiBase + '/Active/' + id + '/Stop', {
+                        method: 'POST',
+                        headers: this.getHeaders()
+                    }).then(function() { SRFPlayRecordings.loadRecordings(); });
+                },
+
+                cancelRecording: function(id) {
+                    fetch(this.apiBase + '/Schedule/' + id, {
+                        method: 'DELETE',
+                        headers: this.getHeaders()
+                    }).then(function() { SRFPlayRecordings.loadRecordings(); });
+                },
+
+                deleteRecording: function(id) {
+                    if (!confirm('Delete this recording and its file?')) return;
+                    fetch(this.apiBase + '/Completed/' + id + '?deleteFile=true', {
+                        method: 'DELETE',
+                        headers: this.getHeaders()
+                    }).then(function() { SRFPlayRecordings.loadRecordings(); });
+                }
+            };
+        </script>
+    </div>

Jellyfin.Plugin.SRFPlay/Configuration/recordingPage.html

@@ -0,0 +1,346 @@
+<div id="SRFPlayRecordingsPage" data-role="page" class="page type-interior pluginConfigurationPage"
+         data-require="emby-button,emby-input">
+        <style>
+            #SRFPlayRecordingsPage .srfrec-wrap { padding: 0 1em; }
+            #SRFPlayRecordingsPage table { width: 100%; border-collapse: collapse; margin: 10px 0 20px; }
+            #SRFPlayRecordingsPage th { text-align: left; padding: 10px 8px; border-bottom: 2px solid #444; color: #aaa; font-size: 0.85em; text-transform: uppercase; }
+            #SRFPlayRecordingsPage td { padding: 10px 8px; border-bottom: 1px solid #2a2a3e; }
+            #SRFPlayRecordingsPage tr:hover { background: rgba(255,255,255,0.04); }
+            #SRFPlayRecordingsPage .btn { padding: 6px 16px; border: none; border-radius: 4px; cursor: pointer; font-size: 0.85em; color: #fff; transition: opacity 0.2s; }
+            #SRFPlayRecordingsPage .btn:hover { opacity: 0.85; }
+            #SRFPlayRecordingsPage .btn-record { background: #4CAF50; }
+            #SRFPlayRecordingsPage .btn-stop { background: #FF9800; }
+            #SRFPlayRecordingsPage .btn-cancel { background: #9E9E9E; }
+            #SRFPlayRecordingsPage .btn-delete { background: #f44336; }
+            #SRFPlayRecordingsPage .btn-refresh { background: #2196F3; margin-bottom: 16px; }
+            #SRFPlayRecordingsPage .status { padding: 3px 8px; border-radius: 3px; font-size: 0.8em; font-weight: 600; color: #fff; }
+            #SRFPlayRecordingsPage .status-scheduled { background: #1565C0; }
+            #SRFPlayRecordingsPage .status-waiting { background: #E65100; }
+            #SRFPlayRecordingsPage .status-recording { background: #2E7D32; }
+            #SRFPlayRecordingsPage .status-failed { background: #C62828; }
+            #SRFPlayRecordingsPage .srfrec-msg { padding: 12px; color: #999; font-style: italic; }
+            #SRFPlayRecordingsPage .srfrec-error { color: #f44; }
+            #SRFPlayRecordingsPage .login-form { max-width: 400px; margin: 40px auto; }
+            #SRFPlayRecordingsPage .login-form input { width: 100%; padding: 10px; margin: 8px 0; background: #2a2a3e; border: 1px solid #444; color: #fff; border-radius: 4px; font-size: 1em; }
+            #SRFPlayRecordingsPage .login-form .btn { width: 100%; padding: 12px; font-size: 1em; margin-top: 12px; }
+        </style>
+        <div data-role="content">
+            <div class="content-primary srfrec-wrap">
+                <div id="srfrecLoginSection" style="display:none;">
+                    <div class="login-form">
+                        <h1>SRF Sport Recordings</h1>
+                        <p class="fieldDescription">Sign in to your Jellyfin server</p>
+                        <input type="text" id="srfrecLoginServer" placeholder="Server URL (e.g. http://192.168.1.50:8096)" />
+                        <input type="text" id="srfrecLoginUser" placeholder="Username" />
+                        <input type="password" id="srfrecLoginPass" placeholder="Password" />
+                        <button type="button" class="btn btn-record" onclick="SRFRec.login()">Sign In</button>
+                        <p id="srfrecLoginError" class="srfrec-error" style="margin-top:10px;"></p>
+                    </div>
+                </div>
+
+                <div id="srfrecMainSection" style="display:none;">
+                    <h1>SRF Sport Recordings</h1>
+                    <p class="fieldDescription">Browse upcoming sport livestreams and schedule recordings. <span id="srfrecUserInfo"></span></p>
+
+                    <h2>Upcoming Sport Livestreams</h2>
+                    <button type="button" class="btn btn-refresh" onclick="SRFRec.loadSchedule()">Refresh Schedule</button>
+                    <div id="srfrecScheduleContainer"><p class="srfrec-msg">Loading schedule...</p></div>
+
+                    <h2>Scheduled &amp; Active Recordings</h2>
+                    <div id="srfrecActiveRecordingsContainer"><p class="srfrec-msg">Loading...</p></div>
+
+                    <h2>Completed Recordings</h2>
+                    <button type="button" class="btn btn-refresh" onclick="SRFRec.loadRecordings()">Refresh</button>
+                    <div id="srfrecCompletedRecordingsContainer"><p class="srfrec-msg">Loading...</p></div>
+                </div>
+            </div>
+        </div>
+
+        <script>
+            var SRFRec = {
+                serverUrl: '',
+                token: '',
+
+                init: function() {
+                    // Check if we're inside Jellyfin's web client (ApiClient available)
+                    if (typeof ApiClient !== 'undefined' && ApiClient.accessToken()) {
+                        this.serverUrl = ApiClient.serverAddress();
+                        this.token = ApiClient.accessToken();
+                        this.showMain();
+                        return;
+                    }
+
+                    // Check localStorage for saved session
+                    var saved = localStorage.getItem('srfRecSession');
+                    if (saved) {
+                        try {
+                            var session = JSON.parse(saved);
+                            this.serverUrl = session.serverUrl;
+                            this.token = session.token;
+                            // Verify token still works
+                            this.verifySession(session);
+                            return;
+                        } catch(e) { /* fall through to login */ }
+                    }
+
+                    // Show login form
+                    var serverInput = document.getElementById('srfrecLoginServer');
+                    serverInput.value = window.location.origin;
+                    document.getElementById('srfrecLoginSection').style.display = 'block';
+                },
+
+                verifySession: function(session) {
+                    var self = this;
+                    fetch(this.serverUrl + '/System/Info', {
+                        headers: { 'X-Emby-Token': this.token }
+                    }).then(function(r) {
+                        if (r.ok) {
+                            document.getElementById('srfrecUserInfo').textContent = '(Server: ' + self.serverUrl + ')';
+                            self.showMain();
+                        } else {
+                            localStorage.removeItem('srfRecSession');
+                            document.getElementById('srfrecLoginSection').style.display = 'block';
+                        }
+                    }).catch(function() {
+                        localStorage.removeItem('srfRecSession');
+                        document.getElementById('srfrecLoginSection').style.display = 'block';
+                    });
+                },
+
+                login: function() {
+                    var self = this;
+                    var server = document.getElementById('srfrecLoginServer').value.replace(/\/+$/, '');
+                    var user = document.getElementById('srfrecLoginUser').value;
+                    var pass = document.getElementById('srfrecLoginPass').value;
+                    var errorEl = document.getElementById('srfrecLoginError');
+                    errorEl.textContent = '';
+
+                    fetch(server + '/Users/AuthenticateByName', {
+                        method: 'POST',
+                        headers: {
+                            'Content-Type': 'application/json',
+                            'X-Emby-Authorization': 'MediaBrowser Client="SRF Recordings", Device="Web", DeviceId="srfrec-' + Date.now() + '", Version="1.0.0"'
+                        },
+                        body: JSON.stringify({ Username: user, Pw: pass })
+                    })
+                    .then(function(r) {
+                        if (!r.ok) throw new Error('Authentication failed');
+                        return r.json();
+                    })
+                    .then(function(data) {
+                        self.serverUrl = server;
+                        self.token = data.AccessToken;
+                        localStorage.setItem('srfRecSession', JSON.stringify({
+                            serverUrl: server,
+                            token: data.AccessToken,
+                            userName: data.User.Name
+                        }));
+                        document.getElementById('srfrecUserInfo').textContent = '(Signed in as ' + data.User.Name + ')';
+                        self.showMain();
+                    })
+                    .catch(function(err) {
+                        errorEl.textContent = err.message;
+                    });
+                },
+
+                showMain: function() {
+                    document.getElementById('srfrecLoginSection').style.display = 'none';
+                    document.getElementById('srfrecMainSection').style.display = 'block';
+                    this.loadSchedule();
+                    this.loadRecordings();
+                },
+
+                getHeaders: function() {
+                    return { 'X-Emby-Token': this.token };
+                },
+
+                formatDate: function(dateStr) {
+                    if (!dateStr) return 'N/A';
+                    var d = new Date(dateStr);
+                    return d.toLocaleDateString() + ' ' + d.toLocaleTimeString([], {hour: '2-digit', minute:'2-digit'});
+                },
+
+                formatSize: function(bytes) {
+                    if (!bytes) return '';
+                    if (bytes > 1073741824) return (bytes / 1073741824).toFixed(1) + ' GB';
+                    if (bytes > 1048576) return (bytes / 1048576).toFixed(0) + ' MB';
+                    return (bytes / 1024).toFixed(0) + ' KB';
+                },
+
+                loadSchedule: function() {
+                    var container = document.getElementById('srfrecScheduleContainer');
+                    container.innerHTML = '<p class="srfrec-msg">Loading schedule...</p>';
+
+                    fetch(this.serverUrl + '/Plugins/SRFPlay/Recording/Schedule', { headers: this.getHeaders() })
+                        .then(function(r) { return r.json(); })
+                        .then(function(programs) {
+                            if (!programs || programs.length === 0) {
+                                container.innerHTML = '<p class="srfrec-msg">No upcoming sport livestreams found.</p>';
+                                return;
+                            }
+
+                            var html = '<table>';
+                            html += '<thead><tr><th>Title</th><th>Start</th><th>End</th><th>Action</th></tr></thead><tbody>';
+
+                            programs.forEach(function(p) {
+                                html += '<tr>';
+                                html += '<td>' + (p.title || 'Unknown') + '</td>';
+                                html += '<td>' + SRFRec.formatDate(p.validFrom || p.date) + '</td>';
+                                html += '<td>' + SRFRec.formatDate(p.validTo) + '</td>';
+                                html += '<td><button type="button" class="btn btn-record" onclick="SRFRec.scheduleRecording(\'' + encodeURIComponent(p.urn) + '\')">Record</button></td>';
+                                html += '</tr>';
+                            });
+
+                            html += '</tbody></table>';
+                            container.innerHTML = html;
+                        })
+                        .catch(function(err) {
+                            container.innerHTML = '<p class="srfrec-error">Error loading schedule: ' + err.message + '</p>';
+                        });
+                },
+
+                scheduleRecording: function(encodedUrn) {
+                    var self = this;
+                    fetch(this.serverUrl + '/Plugins/SRFPlay/Recording/Schedule/' + encodedUrn, {
+                        method: 'POST',
+                        headers: this.getHeaders()
+                    })
+                    .then(function(r) {
+                        if (r.ok) {
+                            alert('Recording scheduled!');
+                            self.loadRecordings();
+                        } else {
+                            alert('Failed to schedule recording');
+                        }
+                    })
+                    .catch(function(err) { alert('Error: ' + err.message); });
+                },
+
+                loadRecordings: function() {
+                    this.loadActiveRecordings();
+                    this.loadCompletedRecordings();
+                },
+
+                loadActiveRecordings: function() {
+                    var container = document.getElementById('srfrecActiveRecordingsContainer');
+                    container.innerHTML = '<p class="srfrec-msg">Loading...</p>';
+
+                    fetch(this.serverUrl + '/Plugins/SRFPlay/Recording/All', { headers: this.getHeaders() })
+                        .then(function(r) { return r.json(); })
+                        .then(function(recordings) {
+                            var activeStates = ['Scheduled', 'WaitingForStream', 'Recording', 0, 1, 2];
+                            var active = recordings.filter(function(r) {
+                                return activeStates.indexOf(r.state) !== -1;
+                            });
+
+                            if (active.length === 0) {
+                                container.innerHTML = '<p class="srfrec-msg">No scheduled or active recordings.</p>';
+                                return;
+                            }
+
+                            var stateMap = {
+                                'Scheduled': {label: 'Scheduled', cls: 'status-scheduled'},
+                                'WaitingForStream': {label: 'Waiting', cls: 'status-waiting'},
+                                'Recording': {label: 'Recording', cls: 'status-recording'},
+                                0: {label: 'Scheduled', cls: 'status-scheduled'},
+                                1: {label: 'Waiting', cls: 'status-waiting'},
+                                2: {label: 'Recording', cls: 'status-recording'}
+                            };
+
+                            var html = '<table>';
+                            html += '<thead><tr><th>Title</th><th>Status</th><th>Start</th><th>Action</th></tr></thead><tbody>';
+
+                            active.forEach(function(r) {
+                                var st = stateMap[r.state] || {label: r.state, cls: ''};
+                                html += '<tr>';
+                                html += '<td>' + (r.title || 'Unknown') + '</td>';
+                                html += '<td><span class="status ' + st.cls + '">' + st.label + '</span></td>';
+                                html += '<td>' + SRFRec.formatDate(r.validFrom) + '</td>';
+                                html += '<td>';
+                                if (r.state === 2 || r.state === 'Recording') {
+                                    html += '<button type="button" class="btn btn-stop" onclick="SRFRec.stopRecording(\'' + r.id + '\')">Stop</button>';
+                                } else {
+                                    html += '<button type="button" class="btn btn-cancel" onclick="SRFRec.cancelRecording(\'' + r.id + '\')">Cancel</button>';
+                                }
+                                html += '</td></tr>';
+                            });
+
+                            html += '</tbody></table>';
+                            container.innerHTML = html;
+                        })
+                        .catch(function(err) {
+                            container.innerHTML = '<p class="srfrec-error">Error: ' + err.message + '</p>';
+                        });
+                },
+
+                loadCompletedRecordings: function() {
+                    var container = document.getElementById('srfrecCompletedRecordingsContainer');
+                    container.innerHTML = '<p class="srfrec-msg">Loading...</p>';
+
+                    fetch(this.serverUrl + '/Plugins/SRFPlay/Recording/Completed', { headers: this.getHeaders() })
+                        .then(function(r) { return r.json(); })
+                        .then(function(recordings) {
+                            if (!recordings || recordings.length === 0) {
+                                container.innerHTML = '<p class="srfrec-msg">No completed recordings.</p>';
+                                return;
+                            }
+
+                            var html = '<table>';
+                            html += '<thead><tr><th>Title</th><th>Recorded</th><th>Size</th><th>Action</th></tr></thead><tbody>';
+
+                            recordings.forEach(function(r) {
+                                html += '<tr>';
+                                html += '<td>' + (r.title || 'Unknown') + '</td>';
+                                html += '<td>' + SRFRec.formatDate(r.recordingStartedAt) + '</td>';
+                                html += '<td>' + SRFRec.formatSize(r.fileSizeBytes) + '</td>';
+                                html += '<td><button type="button" class="btn btn-delete" onclick="SRFRec.deleteRecording(\'' + r.id + '\')">Delete</button></td>';
+                                html += '</tr>';
+                            });
+
+                            html += '</tbody></table>';
+                            container.innerHTML = html;
+                        })
+                        .catch(function(err) {
+                            container.innerHTML = '<p class="srfrec-error">Error: ' + err.message + '</p>';
+                        });
+                },
+
+                stopRecording: function(id) {
+                    var self = this;
+                    fetch(this.serverUrl + '/Plugins/SRFPlay/Recording/Active/' + id + '/Stop', {
+                        method: 'POST',
+                        headers: this.getHeaders()
+                    }).then(function() { self.loadRecordings(); });
+                },
+
+                cancelRecording: function(id) {
+                    var self = this;
+                    fetch(this.serverUrl + '/Plugins/SRFPlay/Recording/Schedule/' + id, {
+                        method: 'DELETE',
+                        headers: this.getHeaders()
+                    }).then(function() { self.loadRecordings(); });
+                },
+
+                deleteRecording: function(id) {
+                    if (!confirm('Delete this recording and its file?')) return;
+                    var self = this;
+                    fetch(this.serverUrl + '/Plugins/SRFPlay/Recording/Completed/' + id + '?deleteFile=true', {
+                        method: 'DELETE',
+                        headers: this.getHeaders()
+                    }).then(function() { self.loadRecordings(); });
+                }
+            };
+
+            (function() {
+                var page = document.querySelector('#SRFPlayRecordingsPage');
+                if (page && typeof page.addEventListener === 'function' && typeof ApiClient !== 'undefined') {
+                    // Inside the Jellyfin dashboard: defer to the page lifecycle so we
+                    // never run during the config page's view and never hijack routing.
+                    page.addEventListener('pageshow', function() { SRFRec.init(); });
+                } else {
+                    // Standalone (e.g. TV/browser): initialise immediately.
+                    SRFRec.init();
+                }
+            })();
+        </script>
+    </div>

Jellyfin.Plugin.SRFPlay/Constants/ApiEndpoints.cs

@@ -0,0 +1,41 @@
+namespace Jellyfin.Plugin.SRFPlay.Constants;
+
+/// <summary>
+/// Centralized API endpoints and URL templates used throughout the plugin.
+/// </summary>
+public static class ApiEndpoints
+{
+    /// <summary>
+    /// SRG SSR Integration Layer API base URL.
+    /// Used for fetching media compositions, video metadata, and stream URLs.
+    /// </summary>
+    public const string IntegrationLayerBaseUrl = "https://il.srgssr.ch/integrationlayer/2.0";
+
+    /// <summary>
+    /// Play V3 API URL template. Format: {0} = business unit (srf, rts, rsi, rtr, swi).
+    /// Used for fetching shows, topics, and latest content.
+    /// </summary>
+    public const string PlayV3BaseUrlTemplate = "https://www.{0}.ch/play/v3/api/{0}/production/";
+
+    /// <summary>
+    /// Akamai token authentication endpoint.
+    /// Used to get hdnts tokens for stream authentication.
+    /// </summary>
+    public const string AkamaiTokenEndpoint = "https://tp.srgssr.ch/akahd/token";
+
+    /// <summary>
+    /// SRF Play homepage URL.
+    /// </summary>
+    public const string SrfPlayHomepage = "https://www.srf.ch/play";
+
+    /// <summary>
+    /// Base proxy route for stream proxying (relative to server root).
+    /// </summary>
+    public const string ProxyBasePath = "/Plugins/SRFPlay/Proxy";
+
+    /// <summary>
+    /// HLS master manifest route template (relative to server root).
+    /// Format: {0} = item ID.
+    /// </summary>
+    public const string ProxyMasterManifestPath = "/Plugins/SRFPlay/Proxy/{0}/master.m3u8";
+}

Jellyfin.Plugin.SRFPlay/Controllers/MaintenanceController.cs

@@ -0,0 +1,53 @@
+using System.Threading;
+using Jellyfin.Plugin.SRFPlay.Api.Models;
+using Jellyfin.Plugin.SRFPlay.Services.Interfaces;
+using MediaBrowser.Common.Api;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Logging;
+
+namespace Jellyfin.Plugin.SRFPlay.Controllers;
+
+/// <summary>
+/// Administrative maintenance actions for the SRF Play plugin.
+/// </summary>
+[ApiController]
+[Route("Plugins/SRFPlay/Maintenance")]
+[Authorize(Policy = Policies.RequiresElevation)]
+public class MaintenanceController : ControllerBase
+{
+    private readonly ILogger<MaintenanceController> _logger;
+    private readonly IResumeCleanupService _resumeCleanupService;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="MaintenanceController"/> class.
+    /// </summary>
+    /// <param name="logger">The logger.</param>
+    /// <param name="resumeCleanupService">The resume cleanup service.</param>
+    public MaintenanceController(
+        ILogger<MaintenanceController> logger,
+        IResumeCleanupService resumeCleanupService)
+    {
+        _logger = logger;
+        _resumeCleanupService = resumeCleanupService;
+    }
+
+    /// <summary>
+    /// Clears stale SRF Play resume points from every user's "Continue Watching" row.
+    /// </summary>
+    /// <param name="clearAll">
+    /// When true, clears every SRF Play resume point instead of only the stale ones.
+    /// </param>
+    /// <param name="cancellationToken">The cancellation token.</param>
+    /// <returns>A summary of what was inspected and cleared.</returns>
+    [HttpPost("ResumePoints/Cleanup")]
+    [ProducesResponseType(StatusCodes.Status200OK)]
+    public ActionResult<ResumeCleanupResult> CleanupResumePoints(
+        [FromQuery] bool clearAll,
+        CancellationToken cancellationToken)
+    {
+        _logger.LogInformation("Manual Continue Watching cleanup requested (clearAll: {ClearAll})", clearAll);
+        return Ok(_resumeCleanupService.Cleanup(clearAll, cancellationToken));
+    }
+}

Jellyfin.Plugin.SRFPlay/Controllers/RecordingController.cs

@@ -0,0 +1,175 @@
+using System.IO;
+using System.Reflection;
+using System.Threading;
+using System.Threading.Tasks;
+using Jellyfin.Plugin.SRFPlay.Api.Models;
+using Jellyfin.Plugin.SRFPlay.Services.Interfaces;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Logging;
+
+namespace Jellyfin.Plugin.SRFPlay.Controllers;
+
+/// <summary>
+/// Controller for managing sport livestream recordings.
+/// </summary>
+[ApiController]
+[Route("Plugins/SRFPlay/Recording")]
+[Authorize]
+public class RecordingController : ControllerBase
+{
+    private readonly ILogger<RecordingController> _logger;
+    private readonly IRecordingService _recordingService;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="RecordingController"/> class.
+    /// </summary>
+    /// <param name="logger">The logger.</param>
+    /// <param name="recordingService">The recording service.</param>
+    public RecordingController(
+        ILogger<RecordingController> logger,
+        IRecordingService recordingService)
+    {
+        _logger = logger;
+        _recordingService = recordingService;
+    }
+
+    /// <summary>
+    /// Serves the recording manager page accessible to any authenticated user.
+    /// </summary>
+    /// <returns>The recording manager HTML page.</returns>
+    [HttpGet("Page")]
+    [AllowAnonymous]
+    [ProducesResponseType(StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    public IActionResult GetRecordingPage()
+    {
+        var assembly = Assembly.GetExecutingAssembly();
+        var resourceStream = assembly.GetManifestResourceStream("Jellyfin.Plugin.SRFPlay.Configuration.recordingPage.html");
+
+        if (resourceStream == null)
+        {
+            return NotFound("Recording page not found");
+        }
+
+        return File(resourceStream, "text/html");
+    }
+
+    /// <summary>
+    /// Gets upcoming sport livestreams available for recording.
+    /// </summary>
+    /// <param name="cancellationToken">The cancellation token.</param>
+    /// <returns>List of upcoming livestreams.</returns>
+    [HttpGet("Schedule")]
+    [ProducesResponseType(StatusCodes.Status200OK)]
+    public async Task<IActionResult> GetSchedule(CancellationToken cancellationToken)
+    {
+        var schedule = await _recordingService.GetUpcomingScheduleAsync(cancellationToken).ConfigureAwait(false);
+        return Ok(schedule);
+    }
+
+    /// <summary>
+    /// Schedules a livestream for recording by URN.
+    /// </summary>
+    /// <param name="urn">The SRF URN.</param>
+    /// <param name="cancellationToken">The cancellation token.</param>
+    /// <returns>The created recording entry.</returns>
+    [HttpPost("Schedule/{urn}")]
+    [ProducesResponseType(StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status400BadRequest)]
+    public async Task<IActionResult> ScheduleRecording(
+        [FromRoute] string urn,
+        CancellationToken cancellationToken)
+    {
+        if (string.IsNullOrEmpty(urn))
+        {
+            return BadRequest("URN is required");
+        }
+
+        // URN comes URL-encoded with colons, decode it
+        urn = System.Net.WebUtility.UrlDecode(urn);
+
+        _logger.LogInformation("Scheduling recording for URN: {Urn}", urn);
+        var entry = await _recordingService.ScheduleRecordingAsync(urn, cancellationToken).ConfigureAwait(false);
+        return Ok(entry);
+    }
+
+    /// <summary>
+    /// Cancels a scheduled recording.
+    /// </summary>
+    /// <param name="id">The recording ID.</param>
+    /// <returns>OK or NotFound.</returns>
+    [HttpDelete("Schedule/{id}")]
+    [ProducesResponseType(StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    public IActionResult CancelRecording([FromRoute] string id)
+    {
+        return _recordingService.CancelRecording(id) ? Ok() : NotFound();
+    }
+
+    /// <summary>
+    /// Gets currently active recordings.
+    /// </summary>
+    /// <returns>List of active recordings.</returns>
+    [HttpGet("Active")]
+    [ProducesResponseType(StatusCodes.Status200OK)]
+    public IActionResult GetActiveRecordings()
+    {
+        var active = _recordingService.GetRecordings(RecordingState.Recording);
+        return Ok(active);
+    }
+
+    /// <summary>
+    /// Stops an active recording.
+    /// </summary>
+    /// <param name="id">The recording ID.</param>
+    /// <returns>OK or NotFound.</returns>
+    [HttpPost("Active/{id}/Stop")]
+    [ProducesResponseType(StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    public IActionResult StopRecording([FromRoute] string id)
+    {
+        return _recordingService.StopRecording(id) ? Ok() : NotFound();
+    }
+
+    /// <summary>
+    /// Gets completed recordings.
+    /// </summary>
+    /// <returns>List of completed recordings.</returns>
+    [HttpGet("Completed")]
+    [ProducesResponseType(StatusCodes.Status200OK)]
+    public IActionResult GetCompletedRecordings()
+    {
+        var completed = _recordingService.GetRecordings(RecordingState.Completed);
+        return Ok(completed);
+    }
+
+    /// <summary>
+    /// Gets all recordings (all states).
+    /// </summary>
+    /// <returns>List of all recordings.</returns>
+    [HttpGet("All")]
+    [ProducesResponseType(StatusCodes.Status200OK)]
+    public IActionResult GetAllRecordings()
+    {
+        var all = _recordingService.GetRecordings();
+        return Ok(all);
+    }
+
+    /// <summary>
+    /// Deletes a completed recording and its file.
+    /// </summary>
+    /// <param name="id">The recording ID.</param>
+    /// <param name="deleteFile">Whether to delete the file too.</param>
+    /// <returns>OK or NotFound.</returns>
+    [HttpDelete("Completed/{id}")]
+    [ProducesResponseType(StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    public IActionResult DeleteRecording(
+        [FromRoute] string id,
+        [FromQuery] bool deleteFile = true)
+    {
+        return _recordingService.DeleteRecording(id, deleteFile) ? Ok() : NotFound();
+    }
+}

Jellyfin.Plugin.SRFPlay/Controllers/StreamProxyController.cs

@@ -0,0 +1,483 @@
+using System;
+using System.Globalization;
+using System.Net.Http;
+using System.Net.Http.Headers;
+using System.Threading;
+using System.Threading.Tasks;
+using Jellyfin.Plugin.SRFPlay.Services.Interfaces;
+using Jellyfin.Plugin.SRFPlay.Utilities;
+using MediaBrowser.Common.Net;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Logging;
+
+namespace Jellyfin.Plugin.SRFPlay.Controllers;
+
+/// <summary>
+/// Controller for proxying SRF Play streams.
+/// </summary>
+[ApiController]
+[Route("Plugins/SRFPlay/Proxy")]
+public class StreamProxyController : ControllerBase
+{
+    private readonly ILogger<StreamProxyController> _logger;
+    private readonly IStreamProxyService _proxyService;
+    private readonly IHttpClientFactory _httpClientFactory;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="StreamProxyController"/> class.
+    /// </summary>
+    /// <param name="logger">The logger.</param>
+    /// <param name="proxyService">The proxy service.</param>
+    /// <param name="httpClientFactory">The HTTP client factory.</param>
+    public StreamProxyController(
+        ILogger<StreamProxyController> logger,
+        IStreamProxyService proxyService,
+        IHttpClientFactory httpClientFactory)
+    {
+        _logger = logger;
+        _proxyService = proxyService;
+        _httpClientFactory = httpClientFactory;
+    }
+
+    /// <summary>
+    /// Adds CORS headers to allow cross-origin requests from hls.js in browsers.
+    /// </summary>
+    private void AddCorsHeaders()
+    {
+        Response.Headers["Access-Control-Allow-Origin"] = "*";
+        Response.Headers["Access-Control-Allow-Methods"] = "GET, HEAD, OPTIONS";
+        Response.Headers["Access-Control-Allow-Headers"] = "Content-Type, Range, Accept, Origin";
+        Response.Headers["Access-Control-Expose-Headers"] = "Content-Length, Content-Range, Accept-Ranges";
+        Response.Headers["Access-Control-Max-Age"] = "86400"; // Cache preflight for 24 hours
+    }
+
+    /// <summary>
+    /// Adds Cache-Control headers appropriate for the stream type.
+    /// Livestreams need frequent manifest refresh, VOD can be cached longer.
+    /// </summary>
+    /// <param name="itemId">The item ID to check.</param>
+    /// <param name="isVariantManifest">Whether this is a variant (sub) manifest with segment lists.</param>
+    private void AddManifestCacheHeaders(string itemId, bool isVariantManifest = false)
+    {
+        var metadata = _proxyService.GetStreamMetadata(itemId);
+        var isLiveStream = metadata?.IsLiveStream ?? false;
+
+        if (isLiveStream)
+        {
+            if (isVariantManifest)
+            {
+                // Variant manifests contain the segment list which changes every target duration.
+                // Use no-cache to ensure the player always gets the freshest segment list,
+                // preventing requests for segments that have been rotated out of the sliding window.
+                Response.Headers["Cache-Control"] = "no-cache, no-store";
+            }
+            else
+            {
+                // Master manifest is relatively stable (just lists quality variants)
+                Response.Headers["Cache-Control"] = "max-age=2, must-revalidate";
+            }
+
+            _logger.LogDebug("Setting livestream cache headers for {ItemId} (variant={IsVariant})", itemId, isVariantManifest);
+        }
+        else
+        {
+            // VOD manifests are static, can cache longer
+            Response.Headers["Cache-Control"] = "max-age=3600";
+        }
+    }
+
+    /// <summary>
+    /// Handles CORS preflight OPTIONS requests for all proxy endpoints.
+    /// </summary>
+    /// <returns>Empty response with CORS headers.</returns>
+    [HttpOptions("{itemId}/master.m3u8")]
+    [HttpOptions("{itemId}/{manifestPath}.m3u8")]
+    [HttpOptions("{itemId}/{*segmentPath}")]
+    [AllowAnonymous]
+    public IActionResult HandleOptions()
+    {
+        AddCorsHeaders();
+        return Ok();
+    }
+
+    /// <summary>
+    /// Proxies HLS master manifest requests.
+    /// </summary>
+    /// <param name="itemId">The item ID from URL path.</param>
+    /// <param name="cancellationToken">Cancellation token.</param>
+    /// <returns>The HLS manifest with rewritten URLs.</returns>
+    [HttpGet("{itemId}/master.m3u8")]
+    [AllowAnonymous] // Allow anonymous since Jellyfin handles auth upstream
+    [ProducesResponseType(StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    public async Task<IActionResult> GetMasterManifest(
+        [FromRoute] string itemId,
+        CancellationToken cancellationToken)
+    {
+        AddCorsHeaders();
+        _logger.LogInformation("Proxy request for master manifest - Path ItemId: {PathItemId}, Query params: {QueryString}", itemId, Request.QueryString);
+
+        // Try to resolve the actual item ID (path ID might be a session ID during transcoding)
+        var actualItemId = ResolveItemId(itemId);
+
+        try
+        {
+            // Get the correct scheme (https if configured, otherwise use request scheme)
+            var scheme = GetProxyScheme();
+
+            // Build the base proxy URL for this item
+            // Preserve query parameters (token or itemId) from the original request
+            string baseProxyUrl;
+            if (Request.Query.TryGetValue("token", out var token) && !string.IsNullOrEmpty(token))
+            {
+                baseProxyUrl = $"{scheme}://{Request.Host}/Plugins/SRFPlay/Proxy/{itemId}?token={token}";
+                _logger.LogDebug("Using token-based proxy URL with token: {Token}", token.ToString());
+            }
+            else if (actualItemId != itemId)
+            {
+                // Legacy: If path ID differs from resolved ID, add itemId query parameter
+                baseProxyUrl = $"{scheme}://{Request.Host}/Plugins/SRFPlay/Proxy/{itemId}?itemId={actualItemId}";
+                _logger.LogInformation("Path itemId {PathId} differs from resolved itemId {ResolvedId}, adding query parameter", itemId, actualItemId);
+            }
+            else
+            {
+                // Simple case: no query parameters needed
+                baseProxyUrl = $"{scheme}://{Request.Host}/Plugins/SRFPlay/Proxy/{itemId}";
+                _logger.LogDebug("Path itemId matches resolved itemId: {ItemId}", itemId);
+            }
+
+            var manifestContent = await _proxyService.GetRewrittenManifestAsync(actualItemId, baseProxyUrl, cancellationToken).ConfigureAwait(false);
+
+            if (manifestContent == null)
+            {
+                _logger.LogWarning("Manifest not found for path itemId {PathItemId}, resolved itemId {ResolvedItemId} - stream may not be registered", itemId, actualItemId);
+                return NotFound();
+            }
+
+            // Set cache headers based on stream type (live vs VOD)
+            AddManifestCacheHeaders(actualItemId);
+
+            _logger.LogDebug("Returning master manifest for item {ItemId} ({Length} bytes)", itemId, manifestContent.Length);
+            // Use application/x-mpegURL for broader compatibility (Samsung AVPlay requires it)
+            return Content(manifestContent, "application/x-mpegURL; charset=utf-8");
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Error proxying master manifest for item {ItemId}", itemId);
+            return StatusCode(StatusCodes.Status500InternalServerError);
+        }
+    }
+
+    /// <summary>
+    /// Proxies HLS variant manifest requests.
+    /// </summary>
+    /// <param name="itemId">The item ID.</param>
+    /// <param name="manifestPath">The manifest path (e.g., "index_0_av").</param>
+    /// <param name="cancellationToken">Cancellation token.</param>
+    /// <returns>The HLS manifest with rewritten segment URLs.</returns>
+    [HttpGet("{itemId}/{manifestPath}.m3u8")]
+    [AllowAnonymous]
+    [ProducesResponseType(StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    public async Task<IActionResult> GetVariantManifest(
+        [FromRoute] string itemId,
+        [FromRoute] string manifestPath,
+        CancellationToken cancellationToken)
+    {
+        AddCorsHeaders();
+        var fullPath = $"{manifestPath}.m3u8";
+        _logger.LogInformation("Proxy request for variant manifest - ItemId: {ItemId}, Path: {Path}", itemId, fullPath);
+
+        // Try to resolve the actual item ID
+        var actualItemId = ResolveItemId(itemId);
+
+        try
+        {
+            // Fetch the variant manifest as a segment
+            var queryString = Request.QueryString.HasValue ? Request.QueryString.Value : null;
+            var manifestData = await _proxyService.GetSegmentAsync(actualItemId, fullPath, queryString, cancellationToken).ConfigureAwait(false);
+
+            if (manifestData == null)
+            {
+                _logger.LogWarning("Variant manifest not found - ItemId: {ItemId}, Path: {Path}", itemId, fullPath);
+                return NotFound();
+            }
+
+            // Convert to string and rewrite URLs
+            var manifestContent = System.Text.Encoding.UTF8.GetString(manifestData);
+            var scheme = GetProxyScheme();
+            var baseProxyUrl = $"{scheme}://{Request.Host}/Plugins/SRFPlay/Proxy/{itemId}";
+
+            // Extract query parameters from the current request to propagate them
+            string queryParams;
+            if (Request.Query.TryGetValue("token", out var tokenVal) && !string.IsNullOrEmpty(tokenVal))
+            {
+                queryParams = $"?token={tokenVal}";
+            }
+            else if (Request.Query.TryGetValue("itemId", out var itemIdVal) && !string.IsNullOrEmpty(itemIdVal))
+            {
+                queryParams = $"?itemId={itemIdVal}";
+            }
+            else
+            {
+                queryParams = string.Empty;
+            }
+
+            var isLiveStream = _proxyService.GetStreamMetadata(actualItemId)?.IsLiveStream ?? false;
+            var rewrittenContent = _proxyService.RewriteVariantManifestUrls(manifestContent, baseProxyUrl, queryParams, isLiveStream);
+
+            // Set cache headers based on stream type (live vs VOD)
+            // Variant manifests use stricter no-cache for live streams
+            AddManifestCacheHeaders(actualItemId, isVariantManifest: true);
+
+            _logger.LogDebug("Returning variant manifest for item {ItemId} ({Length} bytes)", itemId, rewrittenContent.Length);
+            return Content(rewrittenContent, "application/x-mpegURL; charset=utf-8");
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Error proxying variant manifest - ItemId: {ItemId}, Path: {Path}", itemId, fullPath);
+            return StatusCode(StatusCodes.Status500InternalServerError);
+        }
+    }
+
+    /// <summary>
+    /// Proxies HLS segment requests (.ts, .mp4, .m4s, .aac files).
+    /// </summary>
+    /// <param name="itemId">The item ID.</param>
+    /// <param name="segmentPath">The segment path.</param>
+    /// <param name="cancellationToken">Cancellation token.</param>
+    /// <returns>The segment data.</returns>
+    [HttpGet("{itemId}/{*segmentPath}")]
+    [AllowAnonymous]
+    [ProducesResponseType(StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    public async Task<IActionResult> GetSegment(
+        [FromRoute] string itemId,
+        [FromRoute] string segmentPath,
+        CancellationToken cancellationToken)
+    {
+        AddCorsHeaders();
+        _logger.LogDebug("Proxy request for segment - ItemId: {ItemId}, Path: {SegmentPath}", itemId, segmentPath);
+
+        // Try to resolve the actual item ID
+        var actualItemId = ResolveItemId(itemId);
+
+        try
+        {
+            // Pass the original query string to preserve segment-specific parameters (e.g., ?m=timestamp)
+            var queryString = Request.QueryString.HasValue ? Request.QueryString.Value : null;
+
+            // Use streaming proxy: starts forwarding data to the client before the full segment
+            // is downloaded from the CDN, reducing time-to-first-byte for live streams
+            using var upstreamResponse = await _proxyService.GetSegmentStreamAsync(actualItemId, segmentPath, queryString, cancellationToken).ConfigureAwait(false);
+
+            if (upstreamResponse == null)
+            {
+                _logger.LogWarning("Segment not found - ItemId: {ItemId}, Path: {SegmentPath}", itemId, segmentPath);
+                return NotFound();
+            }
+
+            // Determine content type based on file extension
+            var contentType = MimeTypeHelper.GetSegmentContentType(segmentPath);
+            Response.ContentType = contentType;
+
+            if (upstreamResponse.Content.Headers.ContentLength.HasValue)
+            {
+                Response.ContentLength = upstreamResponse.Content.Headers.ContentLength.Value;
+            }
+
+            // Stream directly from CDN to client without buffering the entire segment in memory
+            await upstreamResponse.Content.CopyToAsync(Response.Body, cancellationToken).ConfigureAwait(false);
+
+            _logger.LogDebug("Streamed segment {SegmentPath} ({ContentType})", segmentPath, contentType);
+            return new EmptyResult();
+        }
+        catch (OperationCanceledException)
+        {
+            // Client disconnected during streaming (e.g., FFmpeg stopped, player seeked).
+            // This is expected behavior, not an error.
+            _logger.LogDebug("Segment streaming canceled - ItemId: {ItemId}, Path: {SegmentPath}", itemId, segmentPath);
+            return new EmptyResult();
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Error proxying segment - ItemId: {ItemId}, Path: {SegmentPath}", itemId, segmentPath);
+
+            // If we already started streaming data to the client, we can't change the status code
+            if (Response.HasStarted)
+            {
+                return new EmptyResult();
+            }
+
+            return StatusCode(StatusCodes.Status500InternalServerError);
+        }
+    }
+
+    /// <summary>
+    /// Gets the correct scheme for proxy URLs (https if public URL is configured with https).
+    /// </summary>
+    /// <returns>The scheme to use (http or https).</returns>
+    private string GetProxyScheme()
+    {
+        // Check if PublicServerUrl is configured and uses HTTPS
+        var config = Plugin.Instance?.Configuration;
+        if (config != null && !string.IsNullOrWhiteSpace(config.PublicServerUrl))
+        {
+            if (config.PublicServerUrl.StartsWith("https://", StringComparison.OrdinalIgnoreCase))
+            {
+                return "https";
+            }
+        }
+
+        // Fall back to request scheme, but prefer https if forwarded headers indicate it
+        if (Request.Headers.TryGetValue("X-Forwarded-Proto", out var forwardedProto))
+        {
+            return forwardedProto.ToString().ToLowerInvariant();
+        }
+
+        return Request.Scheme;
+    }
+
+    /// <summary>
+    /// Resolves the actual item ID from the request.
+    /// </summary>
+    /// <param name="pathItemId">The item ID from the URL path.</param>
+    /// <returns>The resolved item ID.</returns>
+    private string ResolveItemId(string pathItemId)
+    {
+        // Check for token parameter first (preferred method)
+        if (Request.Query.TryGetValue("token", out var token) && !string.IsNullOrEmpty(token))
+        {
+            // Try to resolve the original item ID from the token via the proxy service
+            // We'll need to add a method to StreamProxyService to look up by token
+            _logger.LogInformation("Found token parameter: {Token}, will use path ID {PathItemId} for lookup", token.ToString(), pathItemId);
+            return pathItemId; // Use path ID for now; token prevents Jellyfin from rewriting the URL
+        }
+
+        // Check if there's an itemId query parameter (legacy fallback)
+        if (Request.Query.TryGetValue("itemId", out var queryItemId) && !string.IsNullOrEmpty(queryItemId))
+        {
+            _logger.LogInformation("Using itemId from query parameter: {QueryItemId} (path had: {PathItemId})", queryItemId.ToString(), pathItemId);
+            return queryItemId.ToString();
+        }
+
+        // No query parameters - use path ID as-is (normal case for segments and transcoding sessions)
+        _logger.LogDebug("No query parameters, using path ID as-is: {PathItemId}", pathItemId);
+        return pathItemId;
+    }
+
+    /// <summary>
+    /// Proxies image requests from SRF CDN, fixing Content-Type headers.
+    /// </summary>
+    /// <param name="url">The original image URL (base64 encoded).</param>
+    /// <param name="cancellationToken">Cancellation token.</param>
+    /// <returns>The image data with correct Content-Type.</returns>
+    [HttpGet("Image")]
+    [AllowAnonymous]
+    [ProducesResponseType(StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status400BadRequest)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    public async Task<IActionResult> GetImage(
+        [FromQuery] string url,
+        CancellationToken cancellationToken)
+    {
+        if (string.IsNullOrEmpty(url))
+        {
+            return BadRequest("URL parameter is required");
+        }
+
+        string decodedUrl;
+        try
+        {
+            // Decode base64 URL
+            var bytes = Convert.FromBase64String(url);
+            decodedUrl = System.Text.Encoding.UTF8.GetString(bytes);
+        }
+        catch (FormatException)
+        {
+            _logger.LogWarning("Invalid base64 URL parameter: {Url}", url);
+            return BadRequest("Invalid URL encoding");
+        }
+
+        _logger.LogDebug("Proxying image from: {Url}", decodedUrl);
+
+        try
+        {
+            var httpClient = _httpClientFactory.CreateClient(NamedClient.Default);
+
+            // Create request with proper headers
+            var request = new HttpRequestMessage(HttpMethod.Get, new Uri(decodedUrl));
+            request.Headers.UserAgent.ParseAdd(
+                "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36");
+            request.Headers.Accept.ParseAdd("image/jpeg, image/png, image/webp, image/*;q=0.8");
+
+            var response = await httpClient.SendAsync(
+                request,
+                HttpCompletionOption.ResponseHeadersRead,
+                cancellationToken).ConfigureAwait(false);
+
+            if (!response.IsSuccessStatusCode)
+            {
+                _logger.LogWarning(
+                    "Image fetch failed with status {StatusCode} for {Url}",
+                    response.StatusCode,
+                    decodedUrl);
+                return NotFound();
+            }
+
+            var imageData = await response.Content.ReadAsByteArrayAsync(cancellationToken)
+                .ConfigureAwait(false);
+
+            // Determine correct content type
+            var contentType = MimeTypeHelper.GetImageContentType(decodedUrl);
+
+            _logger.LogDebug(
+                "Returning proxied image ({Length} bytes, {ContentType})",
+                imageData.Length,
+                contentType);
+
+            return File(imageData, contentType);
+        }
+        catch (HttpRequestException ex)
+        {
+            _logger.LogError(ex, "Error fetching image from {Url}", decodedUrl);
+            return StatusCode(StatusCodes.Status502BadGateway);
+        }
+    }
+
+    /// <summary>
+    /// Generates a placeholder image with the given text centered.
+    /// </summary>
+    /// <param name="text">The text to display (base64 encoded).</param>
+    /// <returns>A PNG image with the text centered.</returns>
+    [HttpGet("Placeholder")]
+    [AllowAnonymous]
+    [ProducesResponseType(StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status400BadRequest)]
+    public IActionResult GetPlaceholder([FromQuery] string text)
+    {
+        if (string.IsNullOrEmpty(text))
+        {
+            return BadRequest("Text parameter is required");
+        }
+
+        string decodedText;
+        try
+        {
+            var bytes = Convert.FromBase64String(text);
+            decodedText = System.Text.Encoding.UTF8.GetString(bytes);
+        }
+        catch (FormatException)
+        {
+            _logger.LogWarning("Invalid base64 text parameter: {Text}", text);
+            return BadRequest("Invalid text encoding");
+        }
+
+        _logger.LogDebug("Generating placeholder image for: {Text}", decodedText);
+
+        var imageStream = PlaceholderImageGenerator.GeneratePlaceholder(decodedText);
+        return File(imageStream, "image/png");
+    }
+}

Jellyfin.Plugin.SRFPlay/Jellyfin.Plugin.SRFPlay.csproj

@@ -0,0 +1,43 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+    <RootNamespace>Jellyfin.Plugin.SRFPlay</RootNamespace>
+    <GenerateDocumentationFile>true</GenerateDocumentationFile>
+    <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
+    <Nullable>enable</Nullable>
+    <AnalysisMode>AllEnabledByDefault</AnalysisMode>
+    <CodeAnalysisRuleSet>../jellyfin.ruleset</CodeAnalysisRuleSet>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Jellyfin.Controller" Version="10.9.11" />
+    <PackageReference Include="Jellyfin.Model" Version="10.9.11" />
+    <PackageReference Include="Socks5" Version="1.1.0" />
+    <PackageReference Include="SkiaSharp" Version="2.88.8" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="SerilogAnalyzer" Version="0.15.0" PrivateAssets="All" />
+    <PackageReference Include="StyleCop.Analyzers" Version="1.2.0-beta.556" PrivateAssets="All" />
+    <PackageReference Include="SmartAnalyzers.MultithreadingAnalyzer" Version="1.1.31" PrivateAssets="All" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <None Remove="Configuration\configPage.html" />
+    <EmbeddedResource Include="Configuration\configPage.html" />
+    <None Remove="Configuration\recordingPage.html" />
+    <EmbeddedResource Include="Configuration\recordingPage.html" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <None Remove="..\assests\main logo.png" />
+    <EmbeddedResource Include="..\assests\main logo.png" LogicalName="Jellyfin.Plugin.SRFPlay.Images.logo.png" />
+    <EmbeddedResource Include="..\assests\units\srf-logo.png" LogicalName="Jellyfin.Plugin.SRFPlay.Images.srf-logo.png" />
+    <EmbeddedResource Include="..\assests\units\rts-logo.png" LogicalName="Jellyfin.Plugin.SRFPlay.Images.rts-logo.png" />
+    <EmbeddedResource Include="..\assests\units\rsi-logo.png" LogicalName="Jellyfin.Plugin.SRFPlay.Images.rsi-logo.png" />
+    <EmbeddedResource Include="..\assests\units\rtr-logo.png" LogicalName="Jellyfin.Plugin.SRFPlay.Images.rtr-logo.png" />
+    <EmbeddedResource Include="..\assests\units\swi-logo.png" LogicalName="Jellyfin.Plugin.SRFPlay.Images.swi-logo.png" />
+  </ItemGroup>
+
+</Project>

Jellyfin.Plugin.SRFPlay/Plugin.cs

@@ -1,13 +1,13 @@
 using System;
 using System.Collections.Generic;
 using System.Globalization;
-using Jellyfin.Plugin.Template.Configuration;
+using Jellyfin.Plugin.SRFPlay.Configuration;
 using MediaBrowser.Common.Configuration;
 using MediaBrowser.Common.Plugins;
 using MediaBrowser.Model.Plugins;
 using MediaBrowser.Model.Serialization;
 
-namespace Jellyfin.Plugin.Template;
+namespace Jellyfin.Plugin.SRFPlay;
 
 /// <summary>
 /// The main plugin.
@@ -26,10 +26,10 @@ public class Plugin : BasePlugin<PluginConfiguration>, IHasWebPages
     }
 
     /// <inheritdoc />
-    public override string Name => "Template";
+    public override string Name => "SRF Play";
 
     /// <inheritdoc />
-    public override Guid Id => Guid.Parse("eb5d7894-8eef-4b36-aa6f-5d124e828ce1");
+    public override Guid Id => Guid.Parse("a4b12f86-8c3d-4e9a-b7f2-1d5e6c8a9b4f");
 
     /// <summary>
     /// Gets the current plugin instance.
@@ -39,13 +39,19 @@ public class Plugin : BasePlugin<PluginConfiguration>, IHasWebPages
     /// <inheritdoc />
     public IEnumerable<PluginPageInfo> GetPages()
     {
-        return new[]
+        return
-        {
+        [
             new PluginPageInfo
             {
-                Name = this.Name,
+                Name = Name,
                 EmbeddedResourcePath = string.Format(CultureInfo.InvariantCulture, "{0}.Configuration.configPage.html", GetType().Namespace)
             }
-        };
+
+            // Note: the recordings manager is intentionally NOT registered as a plugin
+            // page. Plugin pages live under the admin Dashboard and are admin-gated, which
+            // both caused a redirect to the recordings page and made it inaccessible to
+            // normal users. Recordings are served as a standalone, user-accessible page at
+            // GET /Plugins/SRFPlay/Recording/Page (see RecordingController).
+        ];
     }
 }

Jellyfin.Plugin.SRFPlay/Providers/SRFEpisodeProvider.cs

@@ -0,0 +1,166 @@
+using System;
+using System.Collections.Generic;
+using System.Net.Http;
+using System.Threading;
+using System.Threading.Tasks;
+using Jellyfin.Plugin.SRFPlay.Services.Interfaces;
+using MediaBrowser.Controller.Entities.TV;
+using MediaBrowser.Controller.Providers;
+using MediaBrowser.Model.Entities;
+using MediaBrowser.Model.Providers;
+using Microsoft.Extensions.Logging;
+
+namespace Jellyfin.Plugin.SRFPlay.Providers;
+
+/// <summary>
+/// Provides metadata for SRF Play episodes.
+/// </summary>
+public class SRFEpisodeProvider : IRemoteMetadataProvider<Episode, EpisodeInfo>
+{
+    private readonly ILogger<SRFEpisodeProvider> _logger;
+    private readonly IMediaCompositionFetcher _compositionFetcher;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="SRFEpisodeProvider"/> class.
+    /// </summary>
+    /// <param name="logger">The logger.</param>
+    /// <param name="compositionFetcher">The media composition fetcher.</param>
+    public SRFEpisodeProvider(
+        ILogger<SRFEpisodeProvider> logger,
+        IMediaCompositionFetcher compositionFetcher)
+    {
+        _logger = logger;
+        _compositionFetcher = compositionFetcher;
+    }
+
+    /// <inheritdoc />
+    public string Name => "SRF Play";
+
+    /// <inheritdoc />
+    public async Task<IEnumerable<RemoteSearchResult>> GetSearchResults(EpisodeInfo searchInfo, CancellationToken cancellationToken)
+    {
+        var results = new List<RemoteSearchResult>();
+
+        try
+        {
+            // Check if we have a URN to search with
+            if (searchInfo.ProviderIds.TryGetValue("SRF", out var urn) && !string.IsNullOrEmpty(urn))
+            {
+                _logger.LogDebug("Searching for episode with URN: {Urn}", urn);
+
+                var mediaComposition = await _compositionFetcher.GetMediaCompositionAsync(urn, cancellationToken).ConfigureAwait(false);
+
+                if (mediaComposition?.HasChapters == true)
+                {
+                    var chapter = mediaComposition.ChapterList[0];
+                    results.Add(new RemoteSearchResult
+                    {
+                        Name = chapter.Title,
+                        Overview = chapter.Description ?? chapter.Lead,
+                        ImageUrl = chapter.ImageUrl,
+                        SearchProviderName = Name,
+                        ProviderIds = new Dictionary<string, string>
+                        {
+                            { "SRF", chapter.Urn }
+                        }
+                    });
+                }
+            }
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Error searching for episode: {Name}", searchInfo.Name);
+        }
+
+        return results;
+    }
+
+    /// <inheritdoc />
+    public async Task<MetadataResult<Episode>> GetMetadata(EpisodeInfo info, CancellationToken cancellationToken)
+    {
+        var result = new MetadataResult<Episode>();
+
+        try
+        {
+            // Check if we have a URN
+            if (!info.ProviderIds.TryGetValue("SRF", out var urn) || string.IsNullOrEmpty(urn))
+            {
+                _logger.LogDebug("No SRF URN found for episode: {Name}", info.Name);
+                return result;
+            }
+
+            _logger.LogDebug("Fetching metadata for episode URN: {Urn}", urn);
+
+            var mediaComposition = await _compositionFetcher.GetMediaCompositionAsync(urn, cancellationToken).ConfigureAwait(false);
+
+            if (mediaComposition?.HasChapters != true)
+            {
+                _logger.LogWarning("No chapter information found for URN: {Urn}", urn);
+                return result;
+            }
+
+            // Get the first chapter (main video)
+            var chapter = mediaComposition.ChapterList[0];
+
+            result.Item = new Episode
+            {
+                Name = chapter.Title,
+                Overview = chapter.Description ?? chapter.Lead,
+                ProviderIds = new Dictionary<string, string>
+                {
+                    { "SRF", chapter.Urn }
+                }
+            };
+
+            // Set episode and season numbers if available
+            if (chapter.EpisodeNumber.HasValue)
+            {
+                result.Item.IndexNumber = chapter.EpisodeNumber;
+            }
+
+            if (chapter.SeasonNumber.HasValue)
+            {
+                result.Item.ParentIndexNumber = chapter.SeasonNumber;
+            }
+
+            // Set premiere date if available
+            if (chapter.Date.HasValue)
+            {
+                result.Item.PremiereDate = chapter.Date;
+            }
+
+            // Set runtime (convert from milliseconds to ticks)
+            if (chapter.Duration > 0)
+            {
+                result.Item.RunTimeTicks = TimeSpan.FromMilliseconds(chapter.Duration).Ticks;
+            }
+
+            // Set series information if available
+            if (mediaComposition.Show != null)
+            {
+                result.Item.SeriesName = mediaComposition.Show.Title;
+
+                // Set series provider ID on the episode
+                if (!string.IsNullOrEmpty(mediaComposition.Show.Urn))
+                {
+                    result.Item.SetProviderId("SRF_Series", mediaComposition.Show.Urn);
+                }
+            }
+
+            result.HasMetadata = true;
+            _logger.LogDebug("Successfully fetched metadata for episode: {Title}", chapter.Title);
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Error fetching metadata for episode: {Name}", info.Name);
+        }
+
+        return result;
+    }
+
+    /// <inheritdoc />
+    public Task<HttpResponseMessage> GetImageResponse(string url, CancellationToken cancellationToken)
+    {
+        throw new NotImplementedException("Image handling is done by SRFImageProvider");
+    }
+}

Jellyfin.Plugin.SRFPlay/Providers/SRFImageProvider.cs

@@ -0,0 +1,205 @@
+using System;
+using System.Collections.Generic;
+using System.Net.Http;
+using System.Net.Http.Headers;
+using System.Threading;
+using System.Threading.Tasks;
+using Jellyfin.Plugin.SRFPlay.Services.Interfaces;
+using Jellyfin.Plugin.SRFPlay.Utilities;
+using MediaBrowser.Common.Net;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Providers;
+using MediaBrowser.Model.Entities;
+using MediaBrowser.Model.Providers;
+using Microsoft.Extensions.Logging;
+
+namespace Jellyfin.Plugin.SRFPlay.Providers;
+
+/// <summary>
+/// Provides images for SRF Play content.
+/// </summary>
+public class SRFImageProvider : IRemoteImageProvider, IHasOrder
+{
+    private readonly IHttpClientFactory _httpClientFactory;
+    private readonly ILogger<SRFImageProvider> _logger;
+    private readonly IMediaCompositionFetcher _compositionFetcher;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="SRFImageProvider"/> class.
+    /// </summary>
+    /// <param name="httpClientFactory">The HTTP client factory.</param>
+    /// <param name="loggerFactory">The logger factory.</param>
+    /// <param name="compositionFetcher">The media composition fetcher.</param>
+    public SRFImageProvider(
+        IHttpClientFactory httpClientFactory,
+        ILoggerFactory loggerFactory,
+        IMediaCompositionFetcher compositionFetcher)
+    {
+        _httpClientFactory = httpClientFactory;
+        _logger = loggerFactory.CreateLogger<SRFImageProvider>();
+        _compositionFetcher = compositionFetcher;
+    }
+
+    /// <inheritdoc />
+    public string Name => "SRF Play";
+
+    /// <inheritdoc />
+    public int Order => 0;
+
+    /// <inheritdoc />
+    public bool Supports(BaseItem item)
+    {
+        // Support movies and episodes for now
+        return item is MediaBrowser.Controller.Entities.Movies.Movie ||
+               item is MediaBrowser.Controller.Entities.TV.Episode ||
+               item is MediaBrowser.Controller.Entities.TV.Series;
+    }
+
+    /// <inheritdoc />
+    public IEnumerable<ImageType> GetSupportedImages(BaseItem item)
+    {
+        return new List<ImageType>
+        {
+            ImageType.Primary,
+            ImageType.Backdrop,
+            ImageType.Thumb
+        };
+    }
+
+    /// <inheritdoc />
+    public async Task<IEnumerable<RemoteImageInfo>> GetImages(BaseItem item, CancellationToken cancellationToken)
+    {
+        var list = new List<RemoteImageInfo>();
+
+        try
+        {
+            // Check if item has SRF URN in provider IDs
+            if (!item.ProviderIds.TryGetValue("SRF", out var urn) || string.IsNullOrEmpty(urn))
+            {
+                _logger.LogDebug("No SRF URN found for item: {ItemName}", item.Name);
+                return list;
+            }
+
+            _logger.LogDebug("Fetching images for SRF URN: {Urn}", urn);
+
+            // Fetch media composition to get image URLs
+            var mediaComposition = await _compositionFetcher.GetMediaCompositionAsync(urn, cancellationToken).ConfigureAwait(false);
+
+            if (mediaComposition == null)
+            {
+                _logger.LogWarning("Failed to fetch media composition for URN: {Urn}", urn);
+                return list;
+            }
+
+            // Extract images from chapters
+            if (mediaComposition.HasChapters)
+            {
+                var chapter = mediaComposition.ChapterList[0];
+                if (!string.IsNullOrEmpty(chapter.ImageUrl))
+                {
+                    _logger.LogDebug("URN {Urn}: Adding chapter image: {ImageUrl}", urn, chapter.ImageUrl);
+                    list.Add(new RemoteImageInfo
+                    {
+                        Url = chapter.ImageUrl,
+                        Type = ImageType.Primary,
+                        ProviderName = Name
+                    });
+
+                    list.Add(new RemoteImageInfo
+                    {
+                        Url = chapter.ImageUrl,
+                        Type = ImageType.Thumb,
+                        ProviderName = Name
+                    });
+                }
+                else
+                {
+                    _logger.LogDebug("URN {Urn}: No chapter image available", urn);
+                }
+            }
+
+            // Extract images from show
+            if (mediaComposition.Show != null)
+            {
+                if (!string.IsNullOrEmpty(mediaComposition.Show.ImageUrl))
+                {
+                    _logger.LogDebug("URN {Urn}: Adding show image: {ImageUrl}", urn, mediaComposition.Show.ImageUrl);
+                    list.Add(new RemoteImageInfo
+                    {
+                        Url = mediaComposition.Show.ImageUrl,
+                        Type = ImageType.Primary,
+                        ProviderName = Name
+                    });
+                }
+
+                if (!string.IsNullOrEmpty(mediaComposition.Show.BannerImageUrl))
+                {
+                    _logger.LogDebug("URN {Urn}: Adding show banner: {BannerUrl}", urn, mediaComposition.Show.BannerImageUrl);
+                    list.Add(new RemoteImageInfo
+                    {
+                        Url = mediaComposition.Show.BannerImageUrl,
+                        Type = ImageType.Backdrop,
+                        ProviderName = Name
+                    });
+                }
+            }
+
+            _logger.LogInformation("URN {Urn}: Found {Count} images for '{ItemName}'", urn, list.Count, item.Name);
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Error fetching images for item: {ItemName}", item.Name);
+        }
+
+        return list;
+    }
+
+    /// <inheritdoc />
+    public async Task<HttpResponseMessage> GetImageResponse(string url, CancellationToken cancellationToken)
+    {
+        _logger.LogDebug("Fetching image from URL: {Url}", url);
+
+        var httpClient = _httpClientFactory.CreateClient(NamedClient.Default);
+
+        // Create request with proper headers - SRF CDN requires User-Agent
+        var request = new HttpRequestMessage(HttpMethod.Get, new Uri(url));
+        request.Headers.UserAgent.ParseAdd("Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36");
+        request.Headers.Accept.ParseAdd("image/jpeg, image/png, image/webp, image/*;q=0.8");
+
+        var response = await httpClient.SendAsync(request, cancellationToken).ConfigureAwait(false);
+
+        var originalContentType = response.Content.Headers.ContentType?.MediaType;
+        _logger.LogDebug(
+            "Image response status: {StatusCode}, Content-Type: {ContentType}, Content-Length: {Length}",
+            response.StatusCode,
+            originalContentType ?? "null",
+            response.Content.Headers.ContentLength);
+
+        // Fix Content-Type if it's not a proper image type - SRF CDN often returns wrong content type
+        // Jellyfin needs correct Content-Type to process images
+        if (response.IsSuccessStatusCode)
+        {
+            var needsContentTypeFix = string.IsNullOrEmpty(originalContentType) ||
+                                      originalContentType == "binary/octet-stream" ||
+                                      originalContentType == "application/octet-stream" ||
+                                      !originalContentType.StartsWith("image/", StringComparison.OrdinalIgnoreCase);
+
+            if (needsContentTypeFix)
+            {
+                // Determine correct content type from URL extension or default to JPEG
+                var contentType = MimeTypeHelper.GetImageContentType(url);
+                if (!string.IsNullOrEmpty(contentType))
+                {
+                    _logger.LogInformation(
+                        "Fixing Content-Type from '{OriginalType}' to '{NewType}' for {Url}",
+                        originalContentType ?? "null",
+                        contentType,
+                        url);
+                    response.Content.Headers.ContentType = new MediaTypeHeaderValue(contentType);
+                }
+            }
+        }
+
+        return response;
+    }
+}

Jellyfin.Plugin.SRFPlay/Providers/SRFMediaProvider.cs

@@ -0,0 +1,179 @@
+using System;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using Jellyfin.Plugin.SRFPlay.Configuration;
+using Jellyfin.Plugin.SRFPlay.Services.Interfaces;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Model.Dto;
+using Microsoft.Extensions.Logging;
+
+namespace Jellyfin.Plugin.SRFPlay.Providers;
+
+/// <summary>
+/// Provides media sources (playback URLs) for SRF Play content.
+/// </summary>
+public class SRFMediaProvider : IMediaSourceProvider
+{
+    private readonly ILogger<SRFMediaProvider> _logger;
+    private readonly IMediaCompositionFetcher _compositionFetcher;
+    private readonly IStreamUrlResolver _streamResolver;
+    private readonly IMediaSourceFactory _mediaSourceFactory;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="SRFMediaProvider"/> class.
+    /// </summary>
+    /// <param name="loggerFactory">The logger factory.</param>
+    /// <param name="compositionFetcher">The media composition fetcher.</param>
+    /// <param name="streamResolver">The stream URL resolver.</param>
+    /// <param name="mediaSourceFactory">The media source factory.</param>
+    public SRFMediaProvider(
+        ILoggerFactory loggerFactory,
+        IMediaCompositionFetcher compositionFetcher,
+        IStreamUrlResolver streamResolver,
+        IMediaSourceFactory mediaSourceFactory)
+    {
+        _logger = loggerFactory.CreateLogger<SRFMediaProvider>();
+        _compositionFetcher = compositionFetcher;
+        _streamResolver = streamResolver;
+        _mediaSourceFactory = mediaSourceFactory;
+    }
+
+    /// <summary>
+    /// Gets the provider name.
+    /// </summary>
+    public string Name => "SRF Play";
+
+    /// <summary>
+    /// Gets media sources for the specified item.
+    /// </summary>
+    /// <param name="item">The item.</param>
+    /// <param name="cancellationToken">The cancellation token.</param>
+    /// <returns>List of media sources.</returns>
+    public async Task<IEnumerable<MediaSourceInfo>> GetMediaSources(BaseItem item, CancellationToken cancellationToken)
+    {
+        var sources = new List<MediaSourceInfo>();
+
+        try
+        {
+            // Check if this is an SRF item
+            if (!item.ProviderIds.TryGetValue("SRF", out var urn) || string.IsNullOrEmpty(urn))
+            {
+                return sources;
+            }
+
+            _logger.LogDebug("GetMediaSources for URN: {Urn}, Item: {ItemName}", urn, item.Name);
+
+            // For scheduled livestreams, use shorter cache TTL (5 minutes) so they refresh when they go live
+            var cacheDuration = urn.Contains("scheduled_livestream", StringComparison.OrdinalIgnoreCase) ? 5 : (int?)null;
+
+            var mediaComposition = await _compositionFetcher.GetMediaCompositionAsync(urn, cancellationToken, cacheDuration).ConfigureAwait(false);
+
+            if (mediaComposition?.HasChapters != true)
+            {
+                _logger.LogWarning("No chapters found for URN: {Urn}", urn);
+                return sources;
+            }
+
+            // Get the first chapter (main video)
+            var chapter = mediaComposition.ChapterList[0];
+
+            // Check if content is expired
+            if (_streamResolver.IsContentExpired(chapter))
+            {
+                _logger.LogWarning("Content expired for URN: {Urn}, ValidTo: {ValidTo}", urn, chapter.ValidTo);
+                return sources;
+            }
+
+            // Check if content has playable streams
+            if (!_streamResolver.HasPlayableContent(chapter))
+            {
+                _logger.LogWarning("No playable content found for URN: {Urn}", urn);
+                return sources;
+            }
+
+            // Get quality preference from config
+            var config = Plugin.Instance?.Configuration;
+            var qualityPref = config?.QualityPreference ?? QualityPreference.HD;
+
+            // Use item ID in hex format without dashes
+            var itemIdStr = item.Id.ToString("N");
+
+            // Use factory to create MediaSourceInfo
+            var mediaSource = await _mediaSourceFactory.CreateMediaSourceAsync(
+                chapter,
+                itemIdStr,
+                urn,
+                qualityPref,
+                cancellationToken).ConfigureAwait(false);
+
+            // For scheduled livestreams, retry with fresh data if no stream URL
+            if (mediaSource == null && chapter.Type == "SCHEDULED_LIVESTREAM")
+            {
+                _logger.LogDebug("URN {Urn}: Scheduled livestream has no stream URL, fetching fresh data", urn);
+
+                // Force fresh fetch with short cache duration
+                var freshMediaComposition = await _compositionFetcher.GetMediaCompositionAsync(urn, cancellationToken, 1).ConfigureAwait(false);
+
+                if (freshMediaComposition?.HasChapters == true)
+                {
+                    var freshChapter = freshMediaComposition.ChapterList[0];
+                    mediaSource = await _mediaSourceFactory.CreateMediaSourceAsync(
+                        freshChapter,
+                        itemIdStr,
+                        urn,
+                        qualityPref,
+                        cancellationToken).ConfigureAwait(false);
+
+                    if (mediaSource != null)
+                    {
+                        chapter = freshChapter;
+                        _logger.LogInformation("URN {Urn}: Got fresh stream URL for scheduled livestream", urn);
+                    }
+                }
+            }
+
+            if (mediaSource == null)
+            {
+                _logger.LogWarning("Could not resolve stream URL for URN: {Urn}", urn);
+                return sources;
+            }
+
+            sources.Add(mediaSource);
+            _logger.LogDebug(
+                "MediaSource created for {Title} - Id={Id}, DirectPlay={DirectPlay}, Transcoding={Transcoding}",
+                chapter.Title,
+                mediaSource.Id,
+                mediaSource.SupportsDirectPlay,
+                mediaSource.SupportsTranscoding);
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Error getting media sources for item: {Name}", item.Name);
+        }
+
+        return sources;
+    }
+
+    /// <summary>
+    /// Gets direct stream provider by unique ID.
+    /// </summary>
+    /// <param name="uniqueId">The unique ID.</param>
+    /// <param name="cancellationToken">The cancellation token.</param>
+    /// <returns>The direct stream provider.</returns>
+    public Task<IDirectStreamProvider?> GetDirectStreamProviderByUniqueId(string uniqueId, CancellationToken cancellationToken)
+    {
+        _logger.LogInformation("GetDirectStreamProviderByUniqueId called with uniqueId: {UniqueId}", uniqueId);
+        // Not needed for HTTP streams
+        return Task.FromResult<IDirectStreamProvider?>(null);
+    }
+
+    /// <inheritdoc />
+    public Task<ILiveStream> OpenMediaSource(string openToken, List<ILiveStream> currentLiveStreams, CancellationToken cancellationToken)
+    {
+        // Not used - RequiresOpening is false, proxy handles authentication directly
+        _logger.LogWarning("OpenMediaSource unexpectedly called with openToken: {OpenToken}", openToken);
+        throw new NotSupportedException("OpenMediaSource not supported - streams use direct proxy access");
+    }
+}

Jellyfin.Plugin.SRFPlay/Providers/SRFSeriesProvider.cs

@@ -0,0 +1,140 @@
+using System;
+using System.Collections.Generic;
+using System.Net.Http;
+using System.Threading;
+using System.Threading.Tasks;
+using Jellyfin.Plugin.SRFPlay.Services.Interfaces;
+using MediaBrowser.Controller.Entities.TV;
+using MediaBrowser.Controller.Providers;
+using MediaBrowser.Model.Providers;
+using Microsoft.Extensions.Logging;
+
+namespace Jellyfin.Plugin.SRFPlay.Providers;
+
+/// <summary>
+/// Provides metadata for SRF Play series/shows.
+/// </summary>
+public class SRFSeriesProvider : IRemoteMetadataProvider<Series, SeriesInfo>
+{
+    private readonly ILogger<SRFSeriesProvider> _logger;
+    private readonly IMediaCompositionFetcher _compositionFetcher;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="SRFSeriesProvider"/> class.
+    /// </summary>
+    /// <param name="logger">The logger.</param>
+    /// <param name="compositionFetcher">The media composition fetcher.</param>
+    public SRFSeriesProvider(
+        ILogger<SRFSeriesProvider> logger,
+        IMediaCompositionFetcher compositionFetcher)
+    {
+        _logger = logger;
+        _compositionFetcher = compositionFetcher;
+    }
+
+    /// <inheritdoc />
+    public string Name => "SRF Play";
+
+    /// <inheritdoc />
+    public async Task<IEnumerable<RemoteSearchResult>> GetSearchResults(SeriesInfo searchInfo, CancellationToken cancellationToken)
+    {
+        var results = new List<RemoteSearchResult>();
+
+        try
+        {
+            // Check if we have a URN to search with
+            if (searchInfo.ProviderIds.TryGetValue("SRF", out var urn) && !string.IsNullOrEmpty(urn))
+            {
+                _logger.LogDebug("Searching for series with URN: {Urn}", urn);
+
+                var mediaComposition = await _compositionFetcher.GetMediaCompositionAsync(urn, cancellationToken).ConfigureAwait(false);
+
+                if (mediaComposition?.Show != null)
+                {
+                    var show = mediaComposition.Show;
+                    results.Add(new RemoteSearchResult
+                    {
+                        Name = show.Title,
+                        Overview = show.Description ?? show.Lead,
+                        ImageUrl = show.ImageUrl,
+                        SearchProviderName = Name,
+                        ProviderIds = new Dictionary<string, string>
+                        {
+                            { "SRF", show.Urn ?? urn }
+                        }
+                    });
+                }
+            }
+            else if (!string.IsNullOrEmpty(searchInfo.Name))
+            {
+                _logger.LogDebug("Name-based search not yet implemented for: {Name}", searchInfo.Name);
+                // TODO: Implement name-based search when SRF provides search API
+            }
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Error searching for series: {Name}", searchInfo.Name);
+        }
+
+        return results;
+    }
+
+    /// <inheritdoc />
+    public async Task<MetadataResult<Series>> GetMetadata(SeriesInfo info, CancellationToken cancellationToken)
+    {
+        var result = new MetadataResult<Series>();
+
+        try
+        {
+            // Check if we have a URN
+            if (!info.ProviderIds.TryGetValue("SRF", out var urn) || string.IsNullOrEmpty(urn))
+            {
+                _logger.LogDebug("No SRF URN found for series: {Name}", info.Name);
+                return result;
+            }
+
+            _logger.LogDebug("Fetching metadata for series URN: {Urn}", urn);
+
+            var mediaComposition = await _compositionFetcher.GetMediaCompositionAsync(urn, cancellationToken).ConfigureAwait(false);
+
+            if (mediaComposition?.Show == null)
+            {
+                _logger.LogWarning("No show information found for URN: {Urn}", urn);
+                return result;
+            }
+
+            var show = mediaComposition.Show;
+
+            result.Item = new Series
+            {
+                Name = show.Title,
+                Overview = show.Description ?? show.Lead,
+                ProviderIds = new Dictionary<string, string>
+                {
+                    { "SRF", show.Urn ?? urn }
+                }
+            };
+
+            // Set additional metadata if available
+            if (!string.IsNullOrEmpty(show.Vendor))
+            {
+                result.Item.Studios = new[] { show.Vendor };
+            }
+
+            result.HasMetadata = true;
+            _logger.LogDebug("Successfully fetched metadata for series: {Title}", show.Title);
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Error fetching metadata for series: {Name}", info.Name);
+        }
+
+        return result;
+    }
+
+    /// <inheritdoc />
+    public Task<HttpResponseMessage> GetImageResponse(string url, CancellationToken cancellationToken)
+    {
+        throw new NotImplementedException("Image handling is done by SRFImageProvider");
+    }
+}

Jellyfin.Plugin.SRFPlay/ScheduledTasks/ContentRefreshTask.cs

@@ -0,0 +1,114 @@
+using System;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using Jellyfin.Plugin.SRFPlay.Services.Interfaces;
+using Jellyfin.Plugin.SRFPlay.Utilities;
+using MediaBrowser.Model.Tasks;
+using Microsoft.Extensions.Logging;
+
+namespace Jellyfin.Plugin.SRFPlay.ScheduledTasks;
+
+/// <summary>
+/// Scheduled task for refreshing SRF Play content.
+/// </summary>
+public class ContentRefreshTask : IScheduledTask
+{
+    private readonly ILogger<ContentRefreshTask> _logger;
+    private readonly IContentRefreshService _contentRefreshService;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="ContentRefreshTask"/> class.
+    /// </summary>
+    /// <param name="logger">The logger instance.</param>
+    /// <param name="contentRefreshService">The content refresh service.</param>
+    public ContentRefreshTask(
+        ILogger<ContentRefreshTask> logger,
+        IContentRefreshService contentRefreshService)
+    {
+        _logger = logger;
+        _contentRefreshService = contentRefreshService;
+    }
+
+    /// <inheritdoc />
+    public string Name => "Refresh SRF Play Content";
+
+    /// <inheritdoc />
+    public string Description => "Refreshes latest and trending content from SRF Play";
+
+    /// <inheritdoc />
+    public string Category => "SRF Play";
+
+    /// <inheritdoc />
+    public string Key => "SRFPlayContentRefresh";
+
+    /// <inheritdoc />
+    public async Task ExecuteAsync(IProgress<double> progress, CancellationToken cancellationToken)
+    {
+        _logger.LogInformation("Starting SRF Play content refresh task");
+        progress?.Report(0);
+
+        try
+        {
+            var config = Plugin.Instance?.Configuration;
+            if (config == null)
+            {
+                _logger.LogWarning("Plugin configuration not available");
+                return;
+            }
+
+            if (!config.EnableLatestContent && !config.EnableTrendingContent)
+            {
+                _logger.LogInformation("Content refresh is disabled in configuration");
+                progress?.Report(100);
+                return;
+            }
+
+            // Refresh content for every business unit (one channel per unit).
+            var units = System.Enum.GetValues<Configuration.BusinessUnit>();
+            foreach (var unit in units)
+            {
+                var businessUnit = unit.ToLowerString();
+
+                if (config.EnableLatestContent)
+                {
+                    _logger.LogInformation("Refreshing latest content for {BusinessUnit}", businessUnit);
+                    progress?.Report(25);
+                    await _contentRefreshService.RefreshLatestContentAsync(businessUnit, cancellationToken).ConfigureAwait(false);
+                }
+
+                if (config.EnableTrendingContent)
+                {
+                    _logger.LogInformation("Refreshing trending content for {BusinessUnit}", businessUnit);
+                    progress?.Report(75);
+                    await _contentRefreshService.RefreshTrendingContentAsync(businessUnit, cancellationToken).ConfigureAwait(false);
+                }
+            }
+
+            progress?.Report(100);
+            _logger.LogInformation("SRF Play content refresh task completed successfully");
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Error during SRF Play content refresh task");
+            throw;
+        }
+    }
+
+    /// <inheritdoc />
+    public IEnumerable<TaskTriggerInfo> GetDefaultTriggers()
+    {
+        var config = Plugin.Instance?.Configuration;
+        var intervalHours = config?.ContentRefreshIntervalHours ?? 6;
+
+        // Run every X hours as configured
+        return new[]
+        {
+            new TaskTriggerInfo
+            {
+                Type = TaskTriggerInfo.TriggerInterval,
+                IntervalTicks = TimeSpan.FromHours(intervalHours).Ticks
+            }
+        };
+    }
+}

Jellyfin.Plugin.SRFPlay/ScheduledTasks/ExpirationCheckTask.cs

@@ -0,0 +1,102 @@
+using System;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using Jellyfin.Plugin.SRFPlay.Services.Interfaces;
+using MediaBrowser.Model.Tasks;
+using Microsoft.Extensions.Logging;
+
+namespace Jellyfin.Plugin.SRFPlay.ScheduledTasks;
+
+/// <summary>
+/// Scheduled task for checking and removing expired SRF Play content.
+/// </summary>
+public class ExpirationCheckTask : IScheduledTask
+{
+    private readonly ILogger<ExpirationCheckTask> _logger;
+    private readonly IContentExpirationService _expirationService;
+    private readonly IStreamProxyService _streamProxyService;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="ExpirationCheckTask"/> class.
+    /// </summary>
+    /// <param name="logger">The logger instance.</param>
+    /// <param name="expirationService">The content expiration service.</param>
+    /// <param name="streamProxyService">The stream proxy service.</param>
+    public ExpirationCheckTask(
+        ILogger<ExpirationCheckTask> logger,
+        IContentExpirationService expirationService,
+        IStreamProxyService streamProxyService)
+    {
+        _logger = logger;
+        _expirationService = expirationService;
+        _streamProxyService = streamProxyService;
+    }
+
+    /// <inheritdoc />
+    public string Name => "Check SRF Play Content Expiration";
+
+    /// <inheritdoc />
+    public string Description => "Checks for expired SRF Play content and removes it from the library";
+
+    /// <inheritdoc />
+    public string Category => "SRF Play";
+
+    /// <inheritdoc />
+    public string Key => "SRFPlayExpirationCheck";
+
+    /// <inheritdoc />
+    public async Task ExecuteAsync(IProgress<double> progress, CancellationToken cancellationToken)
+    {
+        _logger.LogInformation("Starting SRF Play expiration check task");
+        progress?.Report(0);
+
+        try
+        {
+            var config = Plugin.Instance?.Configuration;
+            if (config == null)
+            {
+                _logger.LogWarning("Plugin configuration not available");
+                return;
+            }
+
+            // Check and remove expired content
+            progress?.Report(25);
+            var removedCount = await _expirationService.CheckAndRemoveExpiredContentAsync(cancellationToken).ConfigureAwait(false);
+
+            // Clean up old stream proxy mappings
+            progress?.Report(75);
+            _streamProxyService.CleanupOldMappings();
+
+            progress?.Report(100);
+            _logger.LogInformation("SRF Play expiration check task completed. Removed {Count} expired items", removedCount);
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Error during SRF Play expiration check task");
+            throw;
+        }
+    }
+
+    /// <inheritdoc />
+    public IEnumerable<TaskTriggerInfo> GetDefaultTriggers()
+    {
+        var config = Plugin.Instance?.Configuration;
+        var intervalHours = config?.ExpirationCheckIntervalHours ?? 24;
+
+        // Run daily at 3 AM or every X hours as configured
+        return new[]
+        {
+            new TaskTriggerInfo
+            {
+                Type = TaskTriggerInfo.TriggerDaily,
+                TimeOfDayTicks = TimeSpan.FromHours(3).Ticks
+            },
+            new TaskTriggerInfo
+            {
+                Type = TaskTriggerInfo.TriggerInterval,
+                IntervalTicks = TimeSpan.FromHours(intervalHours).Ticks
+            }
+        };
+    }
+}

Jellyfin.Plugin.SRFPlay/ScheduledTasks/RecordingSchedulerTask.cs

@@ -0,0 +1,76 @@
+using System;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using Jellyfin.Plugin.SRFPlay.Services.Interfaces;
+using MediaBrowser.Model.Tasks;
+using Microsoft.Extensions.Logging;
+
+namespace Jellyfin.Plugin.SRFPlay.ScheduledTasks;
+
+/// <summary>
+/// Scheduled task that checks and manages sport livestream recordings.
+/// Runs every 2 minutes to start scheduled recordings when streams go live
+/// and stop recordings when they end.
+/// </summary>
+public class RecordingSchedulerTask : IScheduledTask
+{
+    private readonly ILogger<RecordingSchedulerTask> _logger;
+    private readonly IRecordingService _recordingService;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="RecordingSchedulerTask"/> class.
+    /// </summary>
+    /// <param name="logger">The logger.</param>
+    /// <param name="recordingService">The recording service.</param>
+    public RecordingSchedulerTask(
+        ILogger<RecordingSchedulerTask> logger,
+        IRecordingService recordingService)
+    {
+        _logger = logger;
+        _recordingService = recordingService;
+    }
+
+    /// <inheritdoc />
+    public string Name => "Process SRF Play Recordings";
+
+    /// <inheritdoc />
+    public string Description => "Checks scheduled recordings and starts/stops them as needed";
+
+    /// <inheritdoc />
+    public string Category => "SRF Play";
+
+    /// <inheritdoc />
+    public string Key => "SRFPlayRecordingScheduler";
+
+    /// <inheritdoc />
+    public async Task ExecuteAsync(IProgress<double> progress, CancellationToken cancellationToken)
+    {
+        _logger.LogDebug("Processing SRF Play recordings");
+        progress?.Report(0);
+
+        try
+        {
+            await _recordingService.ProcessRecordingsAsync(cancellationToken).ConfigureAwait(false);
+            progress?.Report(100);
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Error processing recordings");
+            throw;
+        }
+    }
+
+    /// <inheritdoc />
+    public IEnumerable<TaskTriggerInfo> GetDefaultTriggers()
+    {
+        return new[]
+        {
+            new TaskTriggerInfo
+            {
+                Type = TaskTriggerInfo.TriggerInterval,
+                IntervalTicks = TimeSpan.FromSeconds(30).Ticks
+            }
+        };
+    }
+}

Jellyfin.Plugin.SRFPlay/ScheduledTasks/ResumeCleanupTask.cs

@@ -0,0 +1,87 @@
+using System;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using Jellyfin.Plugin.SRFPlay.Services.Interfaces;
+using MediaBrowser.Model.Tasks;
+using Microsoft.Extensions.Logging;
+
+namespace Jellyfin.Plugin.SRFPlay.ScheduledTasks;
+
+/// <summary>
+/// Scheduled task that clears stale SRF Play resume points from "Continue Watching".
+/// </summary>
+public class ResumeCleanupTask : IScheduledTask
+{
+    private readonly ILogger<ResumeCleanupTask> _logger;
+    private readonly IResumeCleanupService _resumeCleanupService;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="ResumeCleanupTask"/> class.
+    /// </summary>
+    /// <param name="logger">The logger.</param>
+    /// <param name="resumeCleanupService">The resume cleanup service.</param>
+    public ResumeCleanupTask(
+        ILogger<ResumeCleanupTask> logger,
+        IResumeCleanupService resumeCleanupService)
+    {
+        _logger = logger;
+        _resumeCleanupService = resumeCleanupService;
+    }
+
+    /// <inheritdoc />
+    public string Name => "Clean Up SRF Play Continue Watching";
+
+    /// <inheritdoc />
+    public string Description => "Removes stale SRF Play resume points - ended livestreams, abandoned playback and finished programmes - from every user's Continue Watching row";
+
+    /// <inheritdoc />
+    public string Category => "SRF Play";
+
+    /// <inheritdoc />
+    public string Key => "SRFPlayResumeCleanup";
+
+    /// <inheritdoc />
+    public Task ExecuteAsync(IProgress<double> progress, CancellationToken cancellationToken)
+    {
+        _logger.LogInformation("Starting SRF Play Continue Watching cleanup");
+        progress?.Report(0);
+
+        try
+        {
+            var result = _resumeCleanupService.Cleanup(false, cancellationToken);
+
+            progress?.Report(100);
+            _logger.LogInformation(
+                "SRF Play Continue Watching cleanup completed. Cleared {Cleared} of {Inspected} resume points",
+                result.Cleared,
+                result.Inspected);
+        }
+        catch (OperationCanceledException)
+        {
+            _logger.LogInformation("SRF Play Continue Watching cleanup was cancelled");
+            throw;
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Error during SRF Play Continue Watching cleanup");
+            throw;
+        }
+
+        return Task.CompletedTask;
+    }
+
+    /// <inheritdoc />
+    public IEnumerable<TaskTriggerInfo> GetDefaultTriggers()
+    {
+        // Runs after the 3 AM expiration check so items deleted there are already gone.
+        return new[]
+        {
+            new TaskTriggerInfo
+            {
+                Type = TaskTriggerInfo.TriggerDaily,
+                TimeOfDayTicks = TimeSpan.FromHours(4).Ticks
+            }
+        };
+    }
+}

Jellyfin.Plugin.SRFPlay/ServiceRegistrator.cs

@@ -0,0 +1,67 @@
+using Jellyfin.Plugin.SRFPlay.Api;
+using Jellyfin.Plugin.SRFPlay.Channels;
+using Jellyfin.Plugin.SRFPlay.Providers;
+using Jellyfin.Plugin.SRFPlay.ScheduledTasks;
+using Jellyfin.Plugin.SRFPlay.Services;
+using Jellyfin.Plugin.SRFPlay.Services.Interfaces;
+using MediaBrowser.Controller;
+using MediaBrowser.Controller.Channels;
+using MediaBrowser.Controller.Plugins;
+using MediaBrowser.Model.Tasks;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace Jellyfin.Plugin.SRFPlay;
+
+/// <summary>
+/// Service registrator for dependency injection.
+/// </summary>
+public class ServiceRegistrator : IPluginServiceRegistrator
+{
+    /// <inheritdoc />
+    public void RegisterServices(IServiceCollection serviceCollection, IServerApplicationHost applicationHost)
+    {
+        // Register API client factory
+        serviceCollection.AddSingleton<ISRFApiClientFactory, SRFApiClientFactory>();
+
+        // Register core services with interfaces
+        serviceCollection.AddSingleton<IMetadataCache, MetadataCache>();
+        serviceCollection.AddSingleton<IStreamUrlResolver, StreamUrlResolver>();
+        serviceCollection.AddSingleton<IMediaCompositionFetcher, MediaCompositionFetcher>();
+        serviceCollection.AddSingleton<IStreamProxyService, StreamProxyService>();
+        serviceCollection.AddSingleton<IMediaSourceFactory, MediaSourceFactory>();
+        serviceCollection.AddSingleton<IContentExpirationService, ContentExpirationService>();
+        serviceCollection.AddSingleton<IContentRefreshService, ContentRefreshService>();
+        serviceCollection.AddSingleton<ICategoryService, CategoryService>();
+        serviceCollection.AddSingleton<IResumeCleanupService, ResumeCleanupService>();
+
+        // Clears livestream resume points the moment playback stops, so ended broadcasts never
+        // linger in "Continue Watching" waiting for the nightly cleanup task.
+        serviceCollection.AddHostedService<PlaybackResumeGuard>();
+
+        // Register metadata providers
+        serviceCollection.AddSingleton<SRFSeriesProvider>();
+        serviceCollection.AddSingleton<SRFEpisodeProvider>();
+        serviceCollection.AddSingleton<SRFImageProvider>();
+
+        // Register media source provider
+        serviceCollection.AddSingleton<SRFMediaProvider>();
+
+        // Register recording service
+        serviceCollection.AddSingleton<IRecordingService, RecordingService>();
+
+        // Register scheduled tasks
+        serviceCollection.AddSingleton<IScheduledTask, ContentRefreshTask>();
+        serviceCollection.AddSingleton<IScheduledTask, ExpirationCheckTask>();
+        serviceCollection.AddSingleton<IScheduledTask, RecordingSchedulerTask>();
+        serviceCollection.AddSingleton<IScheduledTask, ResumeCleanupTask>();
+
+        // Register one channel (tile) per SRG business unit. Each must be registered as IChannel
+        // for Jellyfin to discover it. A unit that is not in EnabledBusinessUnits returns no
+        // content (its tile appears empty) - see SrgChannelBase.
+        serviceCollection.AddSingleton<IChannel, SrfChannel>();
+        serviceCollection.AddSingleton<IChannel, RtsChannel>();
+        serviceCollection.AddSingleton<IChannel, RsiChannel>();
+        serviceCollection.AddSingleton<IChannel, RtrChannel>();
+        serviceCollection.AddSingleton<IChannel, SwiChannel>();
+    }
+}

Jellyfin.Plugin.SRFPlay/Services/CategoryService.cs

@@ -0,0 +1,128 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Jellyfin.Plugin.SRFPlay.Api;
+using Jellyfin.Plugin.SRFPlay.Api.Models;
+using Jellyfin.Plugin.SRFPlay.Services.Interfaces;
+using Microsoft.Extensions.Logging;
+
+namespace Jellyfin.Plugin.SRFPlay.Services;
+
+/// <summary>
+/// Service for managing topic/category data and filtering.
+/// </summary>
+public class CategoryService : ICategoryService
+{
+    private readonly ILogger<CategoryService> _logger;
+    private readonly ISRFApiClientFactory _apiClientFactory;
+    private readonly TimeSpan _topicsCacheDuration = TimeSpan.FromHours(24);
+
+    // Cache topics per business unit. A single shared cache would return one unit's
+    // topics (e.g. German SRF) even after the user switched to another (e.g. French RTS).
+    private readonly Dictionary<string, (Dictionary<string, PlayV3Topic> Topics, DateTime Expiry)> _topicsCacheByUnit = new(StringComparer.OrdinalIgnoreCase);
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="CategoryService"/> class.
+    /// </summary>
+    /// <param name="logger">The logger.</param>
+    /// <param name="apiClientFactory">The API client factory.</param>
+    public CategoryService(ILogger<CategoryService> logger, ISRFApiClientFactory apiClientFactory)
+    {
+        _logger = logger;
+        _apiClientFactory = apiClientFactory;
+    }
+
+    /// <inheritdoc />
+    public async Task<List<PlayV3Topic>> GetTopicsAsync(string businessUnit, CancellationToken cancellationToken = default)
+    {
+        // Return cached topics for this business unit if still valid
+        if (_topicsCacheByUnit.TryGetValue(businessUnit, out var cached) && DateTime.UtcNow < cached.Expiry)
+        {
+            _logger.LogDebug("Returning cached topics for business unit: {BusinessUnit}", businessUnit);
+            return cached.Topics.Values.ToList();
+        }
+
+        _logger.LogInformation("Fetching topics for business unit: {BusinessUnit}", businessUnit);
+        using var apiClient = _apiClientFactory.CreateClient();
+        var topics = await apiClient.GetAllTopicsAsync(businessUnit, cancellationToken).ConfigureAwait(false);
+
+        if (topics != null && topics.Count > 0)
+        {
+            // Cache topics by ID for quick lookups, scoped to this business unit
+            var byId = topics
+                .Where(t => !string.IsNullOrEmpty(t.Id))
+                .ToDictionary(t => t.Id!, t => t);
+            _topicsCacheByUnit[businessUnit] = (byId, DateTime.UtcNow.Add(_topicsCacheDuration));
+
+            _logger.LogInformation("Cached {Count} topics for business unit: {BusinessUnit}", byId.Count, businessUnit);
+        }
+
+        return topics ?? new List<PlayV3Topic>();
+    }
+
+    /// <inheritdoc />
+    public async Task<PlayV3Topic?> GetTopicByIdAsync(string topicId, string businessUnit, CancellationToken cancellationToken = default)
+    {
+        // Ensure topics are loaded for this business unit
+        if (!_topicsCacheByUnit.TryGetValue(businessUnit, out var cached) || DateTime.UtcNow >= cached.Expiry)
+        {
+            await GetTopicsAsync(businessUnit, cancellationToken).ConfigureAwait(false);
+            _topicsCacheByUnit.TryGetValue(businessUnit, out cached);
+        }
+
+        return cached.Topics?.GetValueOrDefault(topicId);
+    }
+
+    /// <inheritdoc />
+    public async Task<List<PlayV3Show>> GetShowsByTopicAsync(
+        string topicId,
+        string businessUnit,
+        int maxResults = 50,
+        CancellationToken cancellationToken = default)
+    {
+        using var apiClient = _apiClientFactory.CreateClient();
+        var allShows = await apiClient.GetAllShowsAsync(businessUnit, cancellationToken).ConfigureAwait(false);
+
+        if (allShows == null || allShows.Count == 0)
+        {
+            _logger.LogWarning("No shows available for business unit: {BusinessUnit}", businessUnit);
+            return new List<PlayV3Show>();
+        }
+
+        var filteredShows = FilterShowsByTopic(allShows, topicId)
+            .Where(s => s.NumberOfEpisodes > 0)
+            .OrderByDescending(s => s.NumberOfEpisodes)
+            .Take(maxResults)
+            .ToList();
+
+        _logger.LogDebug("Found {Count} shows for topic {TopicId}", filteredShows.Count, topicId);
+        return filteredShows;
+    }
+
+    /// <inheritdoc />
+    public void ClearCache()
+    {
+        _topicsCacheByUnit.Clear();
+        _logger.LogInformation("Topics cache cleared");
+    }
+
+    /// <summary>
+    /// Filters shows by topic ID.
+    /// </summary>
+    /// <param name="shows">The shows to filter.</param>
+    /// <param name="topicId">The topic ID to filter by.</param>
+    /// <returns>Filtered list of shows.</returns>
+    private static IReadOnlyList<PlayV3Show> FilterShowsByTopic(IReadOnlyList<PlayV3Show> shows, string topicId)
+    {
+        if (string.IsNullOrEmpty(topicId))
+        {
+            return shows;
+        }
+
+        return shows
+            .Where(s => s.TopicList != null && s.TopicList.Contains(topicId))
+            .ToList();
+    }
+}

Jellyfin.Plugin.SRFPlay/Services/ContentExpirationService.cs

@@ -0,0 +1,139 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Jellyfin.Plugin.SRFPlay.Services.Interfaces;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Library;
+using Microsoft.Extensions.Logging;
+
+namespace Jellyfin.Plugin.SRFPlay.Services;
+
+/// <summary>
+/// Service for managing content expiration.
+/// </summary>
+public class ContentExpirationService : IContentExpirationService
+{
+    private readonly ILogger<ContentExpirationService> _logger;
+    private readonly ILibraryManager _libraryManager;
+    private readonly IStreamUrlResolver _streamResolver;
+    private readonly IMediaCompositionFetcher _compositionFetcher;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="ContentExpirationService"/> class.
+    /// </summary>
+    /// <param name="loggerFactory">The logger factory.</param>
+    /// <param name="libraryManager">The library manager.</param>
+    /// <param name="streamResolver">The stream URL resolver.</param>
+    /// <param name="compositionFetcher">The media composition fetcher.</param>
+    public ContentExpirationService(
+        ILoggerFactory loggerFactory,
+        ILibraryManager libraryManager,
+        IStreamUrlResolver streamResolver,
+        IMediaCompositionFetcher compositionFetcher)
+    {
+        _logger = loggerFactory.CreateLogger<ContentExpirationService>();
+        _libraryManager = libraryManager;
+        _streamResolver = streamResolver;
+        _compositionFetcher = compositionFetcher;
+    }
+
+    /// <summary>
+    /// Checks for expired content and removes it from the library.
+    /// </summary>
+    /// <param name="cancellationToken">The cancellation token.</param>
+    /// <returns>The number of items removed.</returns>
+    public async Task<int> CheckAndRemoveExpiredContentAsync(CancellationToken cancellationToken)
+    {
+        _logger.LogInformation("Starting content expiration check");
+        var removedCount = 0;
+
+        try
+        {
+            // Get all items with SRF provider ID
+            var query = new InternalItemsQuery
+            {
+                HasAnyProviderId = new Dictionary<string, string> { { "SRF", string.Empty } },
+                IsVirtualItem = false
+            };
+
+            var items = _libraryManager.GetItemList(query);
+            _logger.LogDebug("Found {Count} SRF items to check for expiration", items.Count);
+
+            foreach (var item in items)
+            {
+                if (cancellationToken.IsCancellationRequested)
+                {
+                    break;
+                }
+
+                try
+                {
+                    if (await IsItemExpiredAsync(item, cancellationToken).ConfigureAwait(false))
+                    {
+                        _logger.LogInformation("Removing expired item: {Name} (URN: {Urn})", item.Name, item.ProviderIds.GetValueOrDefault("SRF"));
+
+                        // Delete the item from library
+                        _libraryManager.DeleteItem(
+                            item,
+                            new DeleteOptions
+                            {
+                                DeleteFileLocation = false
+                            },
+                            false);
+
+                        removedCount++;
+                    }
+                }
+                catch (Exception ex)
+                {
+                    _logger.LogError(ex, "Error checking expiration for item: {Name}", item.Name);
+                }
+            }
+
+            _logger.LogInformation("Content expiration check completed. Removed {Count} expired items", removedCount);
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Error during content expiration check");
+        }
+
+        return removedCount;
+    }
+
+    /// <summary>
+    /// Checks if an item is expired.
+    /// </summary>
+    /// <param name="item">The item to check.</param>
+    /// <param name="cancellationToken">The cancellation token.</param>
+    /// <returns>True if the item is expired.</returns>
+    private async Task<bool> IsItemExpiredAsync(BaseItem item, CancellationToken cancellationToken)
+    {
+        var urn = item.ProviderIds.GetValueOrDefault("SRF");
+        if (string.IsNullOrEmpty(urn))
+        {
+            return false;
+        }
+
+        var mediaComposition = await _compositionFetcher.GetMediaCompositionAsync(urn, cancellationToken).ConfigureAwait(false);
+
+        if (mediaComposition?.HasChapters != true)
+        {
+            // Don't treat API failures as expired - the content may still be available
+            // and a transient error (network issue, 403, API outage) shouldn't delete library items
+            _logger.LogWarning("Could not fetch media composition for URN: {Urn}, skipping (not treating as expired)", urn);
+            return false;
+        }
+
+        var chapter = mediaComposition.ChapterList[0];
+        var isExpired = _streamResolver.IsContentExpired(chapter);
+
+        if (isExpired)
+        {
+            _logger.LogDebug("Item {Name} is expired (ValidTo: {ValidTo})", item.Name, chapter.ValidTo);
+        }
+
+        return isExpired;
+    }
+}

Jellyfin.Plugin.SRFPlay/Services/ContentRefreshService.cs

@@ -0,0 +1,173 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Jellyfin.Plugin.SRFPlay.Api;
+using Jellyfin.Plugin.SRFPlay.Services.Interfaces;
+using Jellyfin.Plugin.SRFPlay.Utilities;
+using Microsoft.Extensions.Logging;
+
+namespace Jellyfin.Plugin.SRFPlay.Services;
+
+/// <summary>
+/// Service for refreshing content from SRF API.
+/// </summary>
+public class ContentRefreshService : IContentRefreshService
+{
+    private readonly ILogger<ContentRefreshService> _logger;
+    private readonly ISRFApiClientFactory _apiClientFactory;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="ContentRefreshService"/> class.
+    /// </summary>
+    /// <param name="loggerFactory">The logger factory.</param>
+    /// <param name="apiClientFactory">The API client factory.</param>
+    public ContentRefreshService(
+        ILoggerFactory loggerFactory,
+        ISRFApiClientFactory apiClientFactory)
+    {
+        _logger = loggerFactory.CreateLogger<ContentRefreshService>();
+        _apiClientFactory = apiClientFactory;
+    }
+
+    /// <summary>
+    /// Refreshes latest content from SRF API using Play v3.
+    /// </summary>
+    /// <param name="businessUnit">The business unit to fetch content for (e.g. "srf", "rts").</param>
+    /// <param name="cancellationToken">The cancellation token.</param>
+    /// <returns>List of URNs for new content.</returns>
+    public async Task<List<string>> RefreshLatestContentAsync(string businessUnit, CancellationToken cancellationToken)
+    {
+        var config = Plugin.Instance?.Configuration;
+        if (config == null || !config.EnableLatestContent)
+        {
+            _logger.LogDebug("Latest content refresh is disabled");
+            return new List<string>();
+        }
+
+        return await FetchVideosFromShowsAsync(
+            businessUnit,
+            minEpisodeCount: 0,
+            maxShows: 20,
+            videosPerShow: 1,
+            contentType: "latest",
+            cancellationToken).ConfigureAwait(false);
+    }
+
+    /// <summary>
+    /// Refreshes trending content from SRF API using Play v3.
+    /// Gets videos from shows with the most episodes.
+    /// </summary>
+    /// <param name="businessUnit">The business unit to fetch content for (e.g. "srf", "rts").</param>
+    /// <param name="cancellationToken">The cancellation token.</param>
+    /// <returns>List of URNs for trending content.</returns>
+    public async Task<List<string>> RefreshTrendingContentAsync(string businessUnit, CancellationToken cancellationToken)
+    {
+        var config = Plugin.Instance?.Configuration;
+        if (config == null || !config.EnableTrendingContent)
+        {
+            _logger.LogDebug("Trending content refresh is disabled");
+            return new List<string>();
+        }
+
+        return await FetchVideosFromShowsAsync(
+            businessUnit,
+            minEpisodeCount: 10,
+            maxShows: 15,
+            videosPerShow: 2,
+            contentType: "trending",
+            cancellationToken).ConfigureAwait(false);
+    }
+
+    /// <summary>
+    /// Fetches videos from shows based on filter criteria.
+    /// </summary>
+    private async Task<List<string>> FetchVideosFromShowsAsync(
+        string businessUnit,
+        int minEpisodeCount,
+        int maxShows,
+        int videosPerShow,
+        string contentType,
+        CancellationToken cancellationToken)
+    {
+        var urns = new List<string>();
+
+        try
+        {
+            _logger.LogInformation("Refreshing {ContentType} content for business unit: {BusinessUnit}", contentType, businessUnit);
+
+            using var apiClient = _apiClientFactory.CreateClient();
+            var shows = await apiClient.GetAllShowsAsync(businessUnit, cancellationToken).ConfigureAwait(false);
+
+            if (shows == null || shows.Count == 0)
+            {
+                _logger.LogWarning("No shows found for business unit: {BusinessUnit}", businessUnit);
+                return urns;
+            }
+
+            _logger.LogInformation("Found {Count} shows, fetching {ContentType} content", shows.Count, contentType);
+
+            var filteredShows = shows
+                .Where(s => s.NumberOfEpisodes > minEpisodeCount)
+                .OrderByDescending(s => s.NumberOfEpisodes)
+                .Take(maxShows)
+                .ToList();
+
+            var now = DateTime.UtcNow;
+
+            foreach (var show in filteredShows)
+            {
+                if (show.Id == null || cancellationToken.IsCancellationRequested)
+                {
+                    continue;
+                }
+
+                try
+                {
+                    var videos = await apiClient.GetVideosForShowAsync(businessUnit, show.Id, cancellationToken).ConfigureAwait(false);
+                    if (videos == null || videos.Count == 0)
+                    {
+                        _logger.LogDebug("Show {Show} ({ShowId}): No videos returned from API", show.Title, show.Id);
+                        continue;
+                    }
+
+                    _logger.LogDebug("Show {Show} ({ShowId}): Found {Count} videos", show.Title, show.Id, videos.Count);
+
+                    // Filter to videos that are actually published (validFrom in the past)
+                    var publishedVideos = videos
+                        .Where(v => v.ValidFrom == null || v.ValidFrom.Value.ToUniversalTime() <= now)
+                        .OrderByDescending(v => v.Date)
+                        .Take(videosPerShow)
+                        .ToList();
+
+                    foreach (var video in publishedVideos)
+                    {
+                        if (video.Urn != null)
+                        {
+                            urns.Add(video.Urn);
+                            _logger.LogDebug(
+                                "Added {ContentType} video from show {Show}: {Title} (URN: {Urn})",
+                                contentType,
+                                show.Title,
+                                video.Title,
+                                video.Urn);
+                        }
+                    }
+                }
+                catch (Exception ex)
+                {
+                    _logger.LogWarning(ex, "Error fetching videos for show {ShowId}", show.Id);
+                }
+            }
+
+            _logger.LogInformation("Refreshed {Count} {ContentType} content items from {ShowCount} shows", urns.Count, contentType, filteredShows.Count);
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Error refreshing {ContentType} content", contentType);
+        }
+
+        return urns;
+    }
+}

Jellyfin.Plugin.SRFPlay/Services/Interfaces/ICategoryService.cs

@@ -0,0 +1,48 @@
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using Jellyfin.Plugin.SRFPlay.Api.Models;
+
+namespace Jellyfin.Plugin.SRFPlay.Services.Interfaces;
+
+/// <summary>
+/// Interface for managing topic/category data and filtering.
+/// </summary>
+public interface ICategoryService
+{
+    /// <summary>
+    /// Gets all topics for a business unit.
+    /// </summary>
+    /// <param name="businessUnit">The business unit.</param>
+    /// <param name="cancellationToken">The cancellation token.</param>
+    /// <returns>List of topics.</returns>
+    Task<List<PlayV3Topic>> GetTopicsAsync(string businessUnit, CancellationToken cancellationToken = default);
+
+    /// <summary>
+    /// Gets a topic by ID.
+    /// </summary>
+    /// <param name="topicId">The topic ID.</param>
+    /// <param name="businessUnit">The business unit.</param>
+    /// <param name="cancellationToken">The cancellation token.</param>
+    /// <returns>The topic, or null if not found.</returns>
+    Task<PlayV3Topic?> GetTopicByIdAsync(string topicId, string businessUnit, CancellationToken cancellationToken = default);
+
+    /// <summary>
+    /// Gets shows for a specific topic, sorted by number of episodes.
+    /// </summary>
+    /// <param name="topicId">The topic ID.</param>
+    /// <param name="businessUnit">The business unit.</param>
+    /// <param name="maxResults">Maximum number of results to return.</param>
+    /// <param name="cancellationToken">The cancellation token.</param>
+    /// <returns>List of shows for the topic.</returns>
+    Task<List<PlayV3Show>> GetShowsByTopicAsync(
+        string topicId,
+        string businessUnit,
+        int maxResults = 50,
+        CancellationToken cancellationToken = default);
+
+    /// <summary>
+    /// Clears the topics cache.
+    /// </summary>
+    void ClearCache();
+}

Jellyfin.Plugin.SRFPlay/Services/Interfaces/IContentExpirationService.cs

@@ -0,0 +1,17 @@
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Jellyfin.Plugin.SRFPlay.Services.Interfaces;
+
+/// <summary>
+/// Interface for managing content expiration.
+/// </summary>
+public interface IContentExpirationService
+{
+    /// <summary>
+    /// Checks for expired content and removes it from the library.
+    /// </summary>
+    /// <param name="cancellationToken">The cancellation token.</param>
+    /// <returns>The number of items removed.</returns>
+    Task<int> CheckAndRemoveExpiredContentAsync(CancellationToken cancellationToken);
+}

Jellyfin.Plugin.SRFPlay/Services/Interfaces/IContentRefreshService.cs

@@ -0,0 +1,27 @@
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Jellyfin.Plugin.SRFPlay.Services.Interfaces;
+
+/// <summary>
+/// Interface for refreshing content from SRF API.
+/// </summary>
+public interface IContentRefreshService
+{
+    /// <summary>
+    /// Refreshes latest content from SRF API using Play v3.
+    /// </summary>
+    /// <param name="businessUnit">The business unit to fetch content for (e.g. "srf", "rts").</param>
+    /// <param name="cancellationToken">The cancellation token.</param>
+    /// <returns>List of URNs for new content.</returns>
+    Task<List<string>> RefreshLatestContentAsync(string businessUnit, CancellationToken cancellationToken);
+
+    /// <summary>
+    /// Refreshes trending content from SRF API using Play v3.
+    /// </summary>
+    /// <param name="businessUnit">The business unit to fetch content for (e.g. "srf", "rts").</param>
+    /// <param name="cancellationToken">The cancellation token.</param>
+    /// <returns>List of URNs for trending content.</returns>
+    Task<List<string>> RefreshTrendingContentAsync(string businessUnit, CancellationToken cancellationToken);
+}

Jellyfin.Plugin.SRFPlay/Services/Interfaces/IMediaCompositionFetcher.cs

@@ -0,0 +1,23 @@
+using System.Threading;
+using System.Threading.Tasks;
+using Jellyfin.Plugin.SRFPlay.Api.Models;
+
+namespace Jellyfin.Plugin.SRFPlay.Services.Interfaces;
+
+/// <summary>
+/// Interface for fetching media composition with caching support.
+/// </summary>
+public interface IMediaCompositionFetcher
+{
+    /// <summary>
+    /// Gets media composition by URN, using cache if available.
+    /// </summary>
+    /// <param name="urn">The URN to fetch.</param>
+    /// <param name="cancellationToken">Cancellation token.</param>
+    /// <param name="cacheDurationOverride">Optional override for cache duration (e.g., 5 min for livestreams).</param>
+    /// <returns>The media composition, or null if not found.</returns>
+    Task<MediaComposition?> GetMediaCompositionAsync(
+        string urn,
+        CancellationToken cancellationToken,
+        int? cacheDurationOverride = null);
+}

Jellyfin.Plugin.SRFPlay/Services/Interfaces/IMediaSourceFactory.cs

@@ -0,0 +1,51 @@
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using Jellyfin.Plugin.SRFPlay.Api.Models;
+using Jellyfin.Plugin.SRFPlay.Configuration;
+using MediaBrowser.Model.Dto;
+using MediaBrowser.Model.Entities;
+
+namespace Jellyfin.Plugin.SRFPlay.Services.Interfaces;
+
+/// <summary>
+/// Factory for creating MediaSourceInfo objects with consistent configuration.
+/// </summary>
+public interface IMediaSourceFactory
+{
+    /// <summary>
+    /// Creates a MediaSourceInfo for a chapter with proper stream authentication and proxy registration.
+    /// </summary>
+    /// <param name="chapter">The chapter containing stream resources.</param>
+    /// <param name="itemId">The unique item ID for proxy registration.</param>
+    /// <param name="urn">The URN of the content.</param>
+    /// <param name="qualityPreference">The preferred quality.</param>
+    /// <param name="cancellationToken">The cancellation token.</param>
+    /// <returns>A configured MediaSourceInfo, or null if stream URL cannot be resolved.</returns>
+    Task<MediaSourceInfo?> CreateMediaSourceAsync(
+        Chapter chapter,
+        string itemId,
+        string urn,
+        QualityPreference qualityPreference,
+        CancellationToken cancellationToken = default);
+
+    /// <summary>
+    /// Builds a proxy URL for an item.
+    /// </summary>
+    /// <param name="itemId">The item ID.</param>
+    /// <returns>The full proxy URL including server address.</returns>
+    string BuildProxyUrl(string itemId);
+
+    /// <summary>
+    /// Gets the server base URL (configured public URL or smart URL).
+    /// </summary>
+    /// <returns>The server base URL without trailing slash.</returns>
+    string GetServerBaseUrl();
+
+    /// <summary>
+    /// Creates MediaStream metadata based on quality preference.
+    /// </summary>
+    /// <param name="quality">The quality preference.</param>
+    /// <returns>List of MediaStream objects for video and audio.</returns>
+    IReadOnlyList<MediaStream> CreateMediaStreams(QualityPreference quality);
+}

Jellyfin.Plugin.SRFPlay/Services/Interfaces/IMetadataCache.cs

@@ -0,0 +1,29 @@
+using Jellyfin.Plugin.SRFPlay.Api.Models;
+
+namespace Jellyfin.Plugin.SRFPlay.Services.Interfaces;
+
+/// <summary>
+/// Interface for caching metadata from SRF API.
+/// </summary>
+public interface IMetadataCache
+{
+    /// <summary>
+    /// Gets cached media composition by URN.
+    /// </summary>
+    /// <param name="urn">The URN.</param>
+    /// <param name="cacheDurationMinutes">The cache duration in minutes.</param>
+    /// <returns>The cached media composition, or null if not found or expired.</returns>
+    MediaComposition? GetMediaComposition(string urn, int cacheDurationMinutes);
+
+    /// <summary>
+    /// Sets media composition in cache.
+    /// </summary>
+    /// <param name="urn">The URN.</param>
+    /// <param name="mediaComposition">The media composition to cache.</param>
+    void SetMediaComposition(string urn, MediaComposition mediaComposition);
+
+    /// <summary>
+    /// Clears all cached data.
+    /// </summary>
+    void Clear();
+}

Jellyfin.Plugin.SRFPlay/Services/Interfaces/IRecordingService.cs

@@ -0,0 +1,65 @@
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using Jellyfin.Plugin.SRFPlay.Api.Models;
+using Jellyfin.Plugin.SRFPlay.Api.Models.PlayV3;
+
+namespace Jellyfin.Plugin.SRFPlay.Services.Interfaces;
+
+/// <summary>
+/// Service for managing sport livestream recordings.
+/// </summary>
+public interface IRecordingService
+{
+    /// <summary>
+    /// Gets upcoming sport livestreams that can be recorded.
+    /// </summary>
+    /// <param name="cancellationToken">The cancellation token.</param>
+    /// <returns>List of upcoming sport livestreams.</returns>
+    Task<IReadOnlyList<PlayV3TvProgram>> GetUpcomingScheduleAsync(CancellationToken cancellationToken = default);
+
+    /// <summary>
+    /// Schedules a livestream for recording.
+    /// </summary>
+    /// <param name="urn">The SRF URN to record.</param>
+    /// <param name="cancellationToken">The cancellation token.</param>
+    /// <returns>The created recording entry.</returns>
+    Task<RecordingEntry> ScheduleRecordingAsync(string urn, CancellationToken cancellationToken = default);
+
+    /// <summary>
+    /// Cancels a scheduled recording.
+    /// </summary>
+    /// <param name="recordingId">The recording ID.</param>
+    /// <returns>True if cancelled.</returns>
+    bool CancelRecording(string recordingId);
+
+    /// <summary>
+    /// Stops an active recording.
+    /// </summary>
+    /// <param name="recordingId">The recording ID.</param>
+    /// <returns>True if stopped.</returns>
+    bool StopRecording(string recordingId);
+
+    /// <summary>
+    /// Gets all recordings by state.
+    /// </summary>
+    /// <param name="stateFilter">Optional state filter.</param>
+    /// <returns>List of matching recording entries.</returns>
+    IReadOnlyList<RecordingEntry> GetRecordings(RecordingState? stateFilter = null);
+
+    /// <summary>
+    /// Deletes a completed recording (entry and optionally the file).
+    /// </summary>
+    /// <param name="recordingId">The recording ID.</param>
+    /// <param name="deleteFile">Whether to delete the file too.</param>
+    /// <returns>True if deleted.</returns>
+    bool DeleteRecording(string recordingId, bool deleteFile = true);
+
+    /// <summary>
+    /// Checks scheduled recordings and starts/stops them as needed.
+    /// Called periodically by the scheduler task.
+    /// </summary>
+    /// <param name="cancellationToken">The cancellation token.</param>
+    /// <returns>A task representing the async operation.</returns>
+    Task ProcessRecordingsAsync(CancellationToken cancellationToken = default);
+}

Jellyfin.Plugin.SRFPlay/Services/Interfaces/IResumeCleanupService.cs

@@ -0,0 +1,53 @@
+using System.Collections.Generic;
+using System.Threading;
+using Jellyfin.Data.Entities;
+using Jellyfin.Plugin.SRFPlay.Api.Models;
+using MediaBrowser.Controller.Entities;
+
+namespace Jellyfin.Plugin.SRFPlay.Services.Interfaces;
+
+/// <summary>
+/// Removes stale plugin-owned resume points so ended livestreams and abandoned playback
+/// stop accumulating in every user's "Continue Watching" row.
+/// </summary>
+public interface IResumeCleanupService
+{
+    /// <summary>
+    /// Scans every user's resumable items and clears the resume point of those owned by this
+    /// plugin that match a staleness rule. Items belonging to other plugins or to the regular
+    /// library are never touched.
+    /// </summary>
+    /// <param name="clearAll">
+    /// When true every plugin-owned resume point is cleared regardless of the staleness rules.
+    /// Used by the "Clear all" maintenance action.
+    /// </param>
+    /// <param name="cancellationToken">The cancellation token.</param>
+    /// <returns>A summary of what was inspected and cleared.</returns>
+    ResumeCleanupResult Cleanup(bool clearAll, CancellationToken cancellationToken);
+
+    /// <summary>
+    /// Clears the resume point of a single item for the given users.
+    /// </summary>
+    /// <param name="item">The item whose resume point should be reset.</param>
+    /// <param name="users">The users to clear it for.</param>
+    /// <param name="reason">A short reason, logged for traceability.</param>
+    /// <returns>The number of resume points actually cleared.</returns>
+    int ClearResumePoint(BaseItem item, IEnumerable<User> users, string reason);
+
+    /// <summary>
+    /// Determines whether an item belongs to this plugin (an SRG channel item or a recording).
+    /// </summary>
+    /// <param name="item">The item to test.</param>
+    /// <returns>True if the item is owned by this plugin.</returns>
+    bool IsPluginItem(BaseItem item);
+
+    /// <summary>
+    /// Clears the resume point if the item is one of this plugin's livestreams and livestream
+    /// cleanup is enabled. Called right after playback stops so an ended broadcast never reaches
+    /// "Continue Watching" in the first place, instead of waiting for the nightly task.
+    /// </summary>
+    /// <param name="item">The item that just stopped playing.</param>
+    /// <param name="users">The users the playback was attributed to.</param>
+    /// <returns>The number of resume points cleared.</returns>
+    int ClearLiveStreamResumePoint(BaseItem item, IEnumerable<User> users);
+}

Jellyfin.Plugin.SRFPlay/Services/Interfaces/IStreamProxyService.cs

@@ -0,0 +1,82 @@
+using System.Net.Http;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Jellyfin.Plugin.SRFPlay.Services.Interfaces;
+
+/// <summary>
+/// Interface for proxying SRF Play streams and managing authentication.
+/// </summary>
+public interface IStreamProxyService
+{
+    /// <summary>
+    /// Registers a stream for deferred authentication (authenticates on first playback request).
+    /// Use this when browsing to avoid wasting 30-second tokens before the user clicks play.
+    /// </summary>
+    /// <param name="itemId">The item ID.</param>
+    /// <param name="unauthenticatedUrl">The unauthenticated stream URL.</param>
+    /// <param name="urn">The SRF URN for this content.</param>
+    /// <param name="isLiveStream">Whether this is a livestream.</param>
+    void RegisterStreamDeferred(string itemId, string unauthenticatedUrl, string? urn = null, bool isLiveStream = false);
+
+    /// <summary>
+    /// Gets stream metadata for an item (URN and isLiveStream flag).
+    /// </summary>
+    /// <param name="itemId">The item ID.</param>
+    /// <returns>A tuple of (URN, IsLiveStream), or null if not found.</returns>
+    (string? Urn, bool IsLiveStream)? GetStreamMetadata(string itemId);
+
+    /// <summary>
+    /// Gets the authenticated URL for an item.
+    /// </summary>
+    /// <param name="itemId">The item ID.</param>
+    /// <param name="cancellationToken">Cancellation token.</param>
+    /// <returns>The authenticated URL, or null if not found or expired.</returns>
+    Task<string?> GetAuthenticatedUrlAsync(string itemId, CancellationToken cancellationToken = default);
+
+    /// <summary>
+    /// Fetches and rewrites an HLS manifest to use proxy URLs.
+    /// </summary>
+    /// <param name="itemId">The item ID.</param>
+    /// <param name="baseProxyUrl">The base proxy URL.</param>
+    /// <param name="cancellationToken">Cancellation token.</param>
+    /// <returns>The rewritten manifest content.</returns>
+    Task<string?> GetRewrittenManifestAsync(string itemId, string baseProxyUrl, CancellationToken cancellationToken = default);
+
+    /// <summary>
+    /// Fetches a segment from the original source.
+    /// </summary>
+    /// <param name="itemId">The item ID.</param>
+    /// <param name="segmentPath">The segment path.</param>
+    /// <param name="queryString">The original query string from the request (preserves segment-specific parameters like timestamps).</param>
+    /// <param name="cancellationToken">Cancellation token.</param>
+    /// <returns>The segment content as bytes.</returns>
+    Task<byte[]?> GetSegmentAsync(string itemId, string segmentPath, string? queryString = null, CancellationToken cancellationToken = default);
+
+    /// <summary>
+    /// Fetches a segment from the original source as a streaming response.
+    /// Returns the HttpResponseMessage for streaming directly to the client, reducing TTFB.
+    /// The caller is responsible for disposing the response.
+    /// </summary>
+    /// <param name="itemId">The item ID.</param>
+    /// <param name="segmentPath">The segment path.</param>
+    /// <param name="queryString">The original query string from the request.</param>
+    /// <param name="cancellationToken">Cancellation token.</param>
+    /// <returns>The HTTP response for streaming, or null if not found.</returns>
+    Task<HttpResponseMessage?> GetSegmentStreamAsync(string itemId, string segmentPath, string? queryString = null, CancellationToken cancellationToken = default);
+
+    /// <summary>
+    /// Rewrites URLs in a variant (sub) manifest to point to the proxy.
+    /// </summary>
+    /// <param name="manifestContent">The variant manifest content.</param>
+    /// <param name="baseProxyUrl">The base proxy URL (without query params).</param>
+    /// <param name="queryParams">Query parameters to append to rewritten URLs (e.g., "?token=abc").</param>
+    /// <param name="isLiveStream">Whether this is a livestream; if so an EXT-X-START offset is injected.</param>
+    /// <returns>The rewritten manifest content.</returns>
+    string RewriteVariantManifestUrls(string manifestContent, string baseProxyUrl, string queryParams, bool isLiveStream = false);
+
+    /// <summary>
+    /// Cleans up old and expired stream mappings.
+    /// </summary>
+    void CleanupOldMappings();
+}

Jellyfin.Plugin.SRFPlay/Services/Interfaces/IStreamUrlResolver.cs

@@ -0,0 +1,42 @@
+using System.Threading;
+using System.Threading.Tasks;
+using Jellyfin.Plugin.SRFPlay.Api.Models;
+using Jellyfin.Plugin.SRFPlay.Configuration;
+
+namespace Jellyfin.Plugin.SRFPlay.Services.Interfaces;
+
+/// <summary>
+/// Interface for resolving stream URLs from media composition resources.
+/// </summary>
+public interface IStreamUrlResolver
+{
+    /// <summary>
+    /// Gets the best stream URL from a chapter based on quality preference.
+    /// </summary>
+    /// <param name="chapter">The chapter containing resources.</param>
+    /// <param name="qualityPreference">The quality preference.</param>
+    /// <returns>The stream URL, or null if no suitable stream found.</returns>
+    string? GetStreamUrl(Chapter chapter, QualityPreference qualityPreference);
+
+    /// <summary>
+    /// Checks if a chapter has non-DRM playable content.
+    /// </summary>
+    /// <param name="chapter">The chapter to check.</param>
+    /// <returns>True if playable content is available.</returns>
+    bool HasPlayableContent(Chapter chapter);
+
+    /// <summary>
+    /// Checks if content is expired based on ValidTo date.
+    /// </summary>
+    /// <param name="chapter">The chapter to check.</param>
+    /// <returns>True if the content is expired.</returns>
+    bool IsContentExpired(Chapter chapter);
+
+    /// <summary>
+    /// Authenticates a stream URL by fetching an Akamai token.
+    /// </summary>
+    /// <param name="streamUrl">The unauthenticated stream URL.</param>
+    /// <param name="cancellationToken">Cancellation token.</param>
+    /// <returns>The authenticated stream URL with token.</returns>
+    Task<string> GetAuthenticatedStreamUrlAsync(string streamUrl, CancellationToken cancellationToken = default);
+}

Jellyfin.Plugin.SRFPlay/Services/MediaCompositionFetcher.cs

@@ -0,0 +1,82 @@
+using System.Threading;
+using System.Threading.Tasks;
+using Jellyfin.Plugin.SRFPlay.Api;
+using Jellyfin.Plugin.SRFPlay.Api.Models;
+using Jellyfin.Plugin.SRFPlay.Services.Interfaces;
+using Microsoft.Extensions.Logging;
+
+namespace Jellyfin.Plugin.SRFPlay.Services;
+
+/// <summary>
+/// Service for fetching media composition with caching support.
+/// This consolidates the cache-check → API-fetch → cache-store pattern.
+/// </summary>
+public class MediaCompositionFetcher : IMediaCompositionFetcher
+{
+    private readonly ILogger<MediaCompositionFetcher> _logger;
+    private readonly IMetadataCache _metadataCache;
+    private readonly ISRFApiClientFactory _apiClientFactory;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="MediaCompositionFetcher"/> class.
+    /// </summary>
+    /// <param name="logger">The logger.</param>
+    /// <param name="metadataCache">The metadata cache.</param>
+    /// <param name="apiClientFactory">The API client factory.</param>
+    public MediaCompositionFetcher(
+        ILogger<MediaCompositionFetcher> logger,
+        IMetadataCache metadataCache,
+        ISRFApiClientFactory apiClientFactory)
+    {
+        _logger = logger;
+        _metadataCache = metadataCache;
+        _apiClientFactory = apiClientFactory;
+    }
+
+    /// <inheritdoc />
+    public async Task<MediaComposition?> GetMediaCompositionAsync(
+        string urn,
+        CancellationToken cancellationToken,
+        int? cacheDurationOverride = null)
+    {
+        if (string.IsNullOrEmpty(urn))
+        {
+            _logger.LogDebug("GetMediaCompositionAsync called with null/empty URN");
+            return null;
+        }
+
+        var config = Plugin.Instance?.Configuration;
+        if (config == null)
+        {
+            _logger.LogWarning("Plugin configuration is null, cannot fetch media composition");
+            return null;
+        }
+
+        var cacheDuration = cacheDurationOverride ?? config.CacheDurationMinutes;
+
+        // Try cache first
+        var mediaComposition = _metadataCache.GetMediaComposition(urn, cacheDuration);
+        if (mediaComposition != null)
+        {
+            _logger.LogDebug("Cache hit for URN: {Urn}", urn);
+            return mediaComposition;
+        }
+
+        // Fetch from API
+        _logger.LogDebug("Cache miss for URN: {Urn}, fetching from API", urn);
+        using var apiClient = _apiClientFactory.CreateClient();
+        mediaComposition = await apiClient.GetMediaCompositionByUrnAsync(urn, cancellationToken).ConfigureAwait(false);
+
+        if (mediaComposition != null)
+        {
+            _metadataCache.SetMediaComposition(urn, mediaComposition);
+            _logger.LogDebug("Cached media composition for URN: {Urn}", urn);
+        }
+        else
+        {
+            _logger.LogWarning("Failed to fetch media composition for URN: {Urn}", urn);
+        }
+
+        return mediaComposition;
+    }
+}

Jellyfin.Plugin.SRFPlay/Services/MediaSourceFactory.cs

@@ -0,0 +1,182 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Jellyfin.Plugin.SRFPlay.Api.Models;
+using Jellyfin.Plugin.SRFPlay.Configuration;
+using Jellyfin.Plugin.SRFPlay.Constants;
+using Jellyfin.Plugin.SRFPlay.Services.Interfaces;
+using Jellyfin.Plugin.SRFPlay.Utilities;
+using MediaBrowser.Controller;
+using MediaBrowser.Model.Dto;
+using MediaBrowser.Model.Entities;
+using MediaBrowser.Model.MediaInfo;
+using Microsoft.Extensions.Logging;
+
+namespace Jellyfin.Plugin.SRFPlay.Services;
+
+/// <summary>
+/// Factory for creating MediaSourceInfo objects with consistent configuration.
+/// Consolidates duplicated logic from SRFMediaProvider and SRFPlayChannel.
+/// </summary>
+public class MediaSourceFactory : IMediaSourceFactory
+{
+    private readonly ILogger<MediaSourceFactory> _logger;
+    private readonly IStreamUrlResolver _streamResolver;
+    private readonly IStreamProxyService _proxyService;
+    private readonly IServerApplicationHost _appHost;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="MediaSourceFactory"/> class.
+    /// </summary>
+    /// <param name="logger">The logger.</param>
+    /// <param name="streamResolver">The stream URL resolver.</param>
+    /// <param name="proxyService">The stream proxy service.</param>
+    /// <param name="appHost">The server application host.</param>
+    public MediaSourceFactory(
+        ILogger<MediaSourceFactory> logger,
+        IStreamUrlResolver streamResolver,
+        IStreamProxyService proxyService,
+        IServerApplicationHost appHost)
+    {
+        _logger = logger;
+        _streamResolver = streamResolver;
+        _proxyService = proxyService;
+        _appHost = appHost;
+    }
+
+    /// <inheritdoc />
+    public Task<MediaSourceInfo?> CreateMediaSourceAsync(
+        Chapter chapter,
+        string itemId,
+        string urn,
+        QualityPreference qualityPreference,
+        CancellationToken cancellationToken = default)
+    {
+        // Get stream URL based on quality preference (unauthenticated)
+        var streamUrl = _streamResolver.GetStreamUrl(chapter, qualityPreference);
+
+        if (string.IsNullOrEmpty(streamUrl))
+        {
+            _logger.LogWarning("Could not resolve stream URL for chapter: {ChapterId}", chapter.Id);
+            return Task.FromResult<MediaSourceInfo?>(null);
+        }
+
+        // A scheduled livestream is only treated as live when the broadcast window is open.
+        // Past replays (ValidTo in the past) and upcoming events (ValidFrom in the future)
+        // are treated as VOD to avoid IsInfiniteStream/IgnoreDts flags and FFmpeg -re mode.
+        var isScheduledLivestream = chapter.Type == "SCHEDULED_LIVESTREAM" ||
+                                    UrnHelper.IsLivestreamUrn(urn);
+        var now = DateTime.UtcNow;
+        var isLiveStream = isScheduledLivestream &&
+            (chapter.ValidFrom == null || chapter.ValidFrom.Value.ToUniversalTime() <= now) &&
+            (chapter.ValidTo == null || chapter.ValidTo.Value.ToUniversalTime() > now);
+
+        // Register stream with UNAUTHENTICATED URL - proxy will authenticate on-demand
+        // This avoids wasting 30-second tokens during category browsing
+        _proxyService.RegisterStreamDeferred(itemId, streamUrl, urn, isLiveStream);
+
+        // Build proxy URL
+        var proxyUrl = BuildProxyUrl(itemId);
+
+        _logger.LogDebug(
+            "Created media source for {Title} - ItemId: {ItemId}, IsLiveStream: {IsLiveStream}",
+            chapter.Title,
+            itemId,
+            isLiveStream);
+
+        // Create MediaSourceInfo with codec info so clients know they can direct play
+        // Provide MediaStreams with H.264+AAC so Android TV/ExoPlayer doesn't trigger transcoding
+        var mediaStreams = CreateMediaStreams(qualityPreference);
+
+        var mediaSource = new MediaSourceInfo
+        {
+            Id = itemId,
+            Name = chapter.Title,
+            Path = proxyUrl,
+            Protocol = MediaProtocol.Http,
+            // Use "hls" to trigger hls.js player in web client
+            Container = "hls",
+            SupportsDirectStream = false,
+            SupportsDirectPlay = true,
+            SupportsTranscoding = true,
+            IsRemote = true,
+            Type = MediaSourceType.Default,
+            RunTimeTicks = chapter.Duration > 0 ? TimeSpan.FromMilliseconds(chapter.Duration).Ticks : null,
+            VideoType = VideoType.VideoFile,
+            IsInfiniteStream = isLiveStream,
+            // RequiresOpening = false: proxy handles auth directly, no need for Jellyfin to open the stream
+            RequiresOpening = false,
+            RequiresClosing = false,
+            // Disable probing - we provide stream info directly
+            SupportsProbing = false,
+            ReadAtNativeFramerate = isLiveStream,
+            // Provide codec info so clients know they can direct play H.264+AAC
+            MediaStreams = mediaStreams.ToList(),
+            AnalyzeDurationMs = isLiveStream ? 1000 : 3000,
+            IgnoreDts = isLiveStream,
+            IgnoreIndex = isLiveStream,
+        };
+
+        return Task.FromResult<MediaSourceInfo?>(mediaSource);
+    }
+
+    /// <inheritdoc />
+    public string BuildProxyUrl(string itemId)
+    {
+        return $"{GetServerBaseUrl()}{ApiEndpoints.ProxyMasterManifestPath.Replace("{0}", itemId, StringComparison.Ordinal)}";
+    }
+
+    /// <inheritdoc />
+    public string GetServerBaseUrl()
+    {
+        var config = Plugin.Instance?.Configuration;
+        return config != null && !string.IsNullOrWhiteSpace(config.PublicServerUrl)
+            ? config.PublicServerUrl.TrimEnd('/')
+            : _appHost.GetSmartApiUrl(string.Empty);
+    }
+
+    /// <inheritdoc />
+    public IReadOnlyList<MediaStream> CreateMediaStreams(QualityPreference quality)
+    {
+        // Set resolution/bitrate based on quality preference
+        var (width, height, videoBitrate) = quality switch
+        {
+            QualityPreference.SD => (1280, 720, 2500000),
+            QualityPreference.HD => (1920, 1080, 5000000),
+            _ => (1280, 720, 3000000)
+        };
+
+        return new List<MediaStream>
+        {
+            new MediaStream
+            {
+                Type = MediaStreamType.Video,
+                Codec = "h264",
+                Profile = "high",
+                Level = 40,
+                Width = width,
+                Height = height,
+                BitRate = videoBitrate,
+                BitDepth = 8,
+                IsInterlaced = false,
+                IsDefault = true,
+                Index = 0,
+                IsAVC = true,
+                PixelFormat = "yuv420p"
+            },
+            new MediaStream
+            {
+                Type = MediaStreamType.Audio,
+                Codec = "aac",
+                Profile = "LC",
+                Channels = 2,
+                SampleRate = 48000,
+                BitRate = 128000,
+                IsDefault = true,
+                Index = 1
+            }
+        };
+    }
+}

Jellyfin.Plugin.SRFPlay/Services/MetadataCache.cs

@@ -0,0 +1,117 @@
+using System;
+using System.Collections.Concurrent;
+using Jellyfin.Plugin.SRFPlay.Api.Models;
+using Jellyfin.Plugin.SRFPlay.Services.Interfaces;
+using Microsoft.Extensions.Logging;
+
+namespace Jellyfin.Plugin.SRFPlay.Services;
+
+/// <summary>
+/// Service for caching metadata from SRF API.
+/// </summary>
+public sealed class MetadataCache : IMetadataCache
+{
+    private readonly ILogger<MetadataCache> _logger;
+    private readonly ConcurrentDictionary<string, CacheEntry<MediaComposition>> _mediaCompositionCache;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="MetadataCache"/> class.
+    /// </summary>
+    /// <param name="logger">The logger instance.</param>
+    public MetadataCache(ILogger<MetadataCache> logger)
+    {
+        _logger = logger;
+        _mediaCompositionCache = new ConcurrentDictionary<string, CacheEntry<MediaComposition>>();
+    }
+
+    /// <summary>
+    /// Gets cached media composition by URN.
+    /// </summary>
+    /// <param name="urn">The URN.</param>
+    /// <param name="cacheDurationMinutes">The cache duration in minutes.</param>
+    /// <returns>The cached media composition, or null if not found or expired.</returns>
+    public MediaComposition? GetMediaComposition(string urn, int cacheDurationMinutes)
+    {
+        if (string.IsNullOrEmpty(urn))
+        {
+            return null;
+        }
+
+        if (_mediaCompositionCache.TryGetValue(urn, out var entry))
+        {
+            if (entry.IsValid(cacheDurationMinutes))
+            {
+                _logger.LogDebug("Cache hit for URN: {Urn}", urn);
+                return entry.Value;
+            }
+
+            _logger.LogDebug("Cache entry expired for URN: {Urn}", urn);
+        }
+
+        return null;
+    }
+
+    /// <summary>
+    /// Sets media composition in cache.
+    /// </summary>
+    /// <param name="urn">The URN.</param>
+    /// <param name="mediaComposition">The media composition to cache.</param>
+    public void SetMediaComposition(string urn, MediaComposition mediaComposition)
+    {
+        if (string.IsNullOrEmpty(urn) || mediaComposition == null)
+        {
+            return;
+        }
+
+        var entry = new CacheEntry<MediaComposition>(mediaComposition);
+        _mediaCompositionCache.AddOrUpdate(urn, entry, (key, oldValue) => entry);
+        _logger.LogDebug("Cached media composition for URN: {Urn}", urn);
+    }
+
+    /// <summary>
+    /// Clears all cached data.
+    /// </summary>
+    public void Clear()
+    {
+        _mediaCompositionCache.Clear();
+        _logger.LogInformation("Cleared metadata cache");
+    }
+
+    /// <summary>
+    /// Represents a cached entry with timestamp.
+    /// </summary>
+    /// <typeparam name="T">The type of cached value.</typeparam>
+    private sealed class CacheEntry<T>
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CacheEntry{T}"/> class.
+        /// </summary>
+        /// <param name="value">The value to cache.</param>
+        public CacheEntry(T value)
+        {
+            Value = value;
+            Timestamp = DateTime.UtcNow;
+        }
+
+        /// <summary>
+        /// Gets the cached value.
+        /// </summary>
+        public T Value { get; }
+
+        /// <summary>
+        /// Gets the timestamp when the entry was created.
+        /// </summary>
+        public DateTime Timestamp { get; }
+
+        /// <summary>
+        /// Checks if the cache entry is still valid.
+        /// </summary>
+        /// <param name="cacheDurationMinutes">The cache duration in minutes.</param>
+        /// <returns>True if the entry is still valid.</returns>
+        public bool IsValid(int cacheDurationMinutes)
+        {
+            var expirationTime = Timestamp.AddMinutes(cacheDurationMinutes);
+            return DateTime.UtcNow < expirationTime;
+        }
+    }
+}

Jellyfin.Plugin.SRFPlay/Services/PlaybackResumeGuard.cs

@@ -0,0 +1,79 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using Jellyfin.Plugin.SRFPlay.Services.Interfaces;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Controller.Session;
+using Microsoft.Extensions.Hosting;
+using Microsoft.Extensions.Logging;
+
+namespace Jellyfin.Plugin.SRFPlay.Services;
+
+/// <summary>
+/// Watches for livestream playback ending and immediately drops the resume point Jellyfin
+/// just saved for it. Without this, every livestream a user stops watching sticks in
+/// "Continue Watching" until the nightly cleanup task runs.
+/// </summary>
+public class PlaybackResumeGuard : IHostedService
+{
+    private readonly ILogger<PlaybackResumeGuard> _logger;
+    private readonly ISessionManager _sessionManager;
+    private readonly IResumeCleanupService _resumeCleanupService;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="PlaybackResumeGuard"/> class.
+    /// </summary>
+    /// <param name="logger">The logger.</param>
+    /// <param name="sessionManager">The session manager raising playback events.</param>
+    /// <param name="resumeCleanupService">The resume cleanup service.</param>
+    public PlaybackResumeGuard(
+        ILogger<PlaybackResumeGuard> logger,
+        ISessionManager sessionManager,
+        IResumeCleanupService resumeCleanupService)
+    {
+        _logger = logger;
+        _sessionManager = sessionManager;
+        _resumeCleanupService = resumeCleanupService;
+    }
+
+    /// <inheritdoc />
+    public Task StartAsync(CancellationToken cancellationToken)
+    {
+        _sessionManager.PlaybackStopped += OnPlaybackStopped;
+        _logger.LogDebug("PlaybackResumeGuard attached to session manager");
+        return Task.CompletedTask;
+    }
+
+    /// <inheritdoc />
+    public Task StopAsync(CancellationToken cancellationToken)
+    {
+        _sessionManager.PlaybackStopped -= OnPlaybackStopped;
+        return Task.CompletedTask;
+    }
+
+    private void OnPlaybackStopped(object? sender, PlaybackStopEventArgs e)
+    {
+        // Jellyfin saves the resume point before raising this event, so clearing it here wins.
+        if (e?.Item == null || e.Users == null || e.Users.Count == 0)
+        {
+            return;
+        }
+
+        try
+        {
+            var cleared = _resumeCleanupService.ClearLiveStreamResumePoint(e.Item, e.Users);
+            if (cleared > 0)
+            {
+                _logger.LogDebug(
+                    "Dropped {Count} resume point(s) for finished livestream '{Name}'",
+                    cleared,
+                    e.Item.Name);
+            }
+        }
+        catch (Exception ex)
+        {
+            // Never let a cleanup failure escape into Jellyfin's playback event pipeline.
+            _logger.LogError(ex, "Error clearing livestream resume point for '{Name}'", e.Item.Name);
+        }
+    }
+}

Jellyfin.Plugin.SRFPlay/Services/RecordingService.cs

@@ -0,0 +1,581 @@
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Text.Json;
+using System.Text.RegularExpressions;
+using System.Threading;
+using System.Threading.Tasks;
+using Jellyfin.Plugin.SRFPlay.Api;
+using Jellyfin.Plugin.SRFPlay.Api.Models;
+using Jellyfin.Plugin.SRFPlay.Api.Models.PlayV3;
+using Jellyfin.Plugin.SRFPlay.Services.Interfaces;
+using Jellyfin.Plugin.SRFPlay.Utilities;
+using MediaBrowser.Controller;
+using MediaBrowser.Controller.MediaEncoding;
+using Microsoft.Extensions.Logging;
+
+namespace Jellyfin.Plugin.SRFPlay.Services;
+
+/// <summary>
+/// Service for managing sport livestream recordings using ffmpeg.
+/// </summary>
+public class RecordingService : IRecordingService, IDisposable
+{
+    private readonly ILogger<RecordingService> _logger;
+    private readonly ISRFApiClientFactory _apiClientFactory;
+    private readonly IStreamProxyService _proxyService;
+    private readonly IStreamUrlResolver _streamUrlResolver;
+    private readonly IMediaCompositionFetcher _mediaCompositionFetcher;
+    private readonly IServerApplicationHost _appHost;
+    private readonly IMediaEncoder _mediaEncoder;
+    private readonly ConcurrentDictionary<string, Process> _activeProcesses = new();
+    private static readonly JsonSerializerOptions _jsonOptions = new() { WriteIndented = true };
+    private readonly SemaphoreSlim _persistLock = new(1, 1);
+    private readonly SemaphoreSlim _processLock = new(1, 1);
+    private List<RecordingEntry> _recordings = new();
+    private bool _loaded;
+    private bool _disposed;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="RecordingService"/> class.
+    /// </summary>
+    /// <param name="logger">The logger.</param>
+    /// <param name="apiClientFactory">The API client factory.</param>
+    /// <param name="proxyService">The stream proxy service.</param>
+    /// <param name="streamUrlResolver">The stream URL resolver.</param>
+    /// <param name="mediaCompositionFetcher">The media composition fetcher.</param>
+    /// <param name="appHost">The application host.</param>
+    /// <param name="mediaEncoder">The media encoder for ffmpeg path.</param>
+    public RecordingService(
+        ILogger<RecordingService> logger,
+        ISRFApiClientFactory apiClientFactory,
+        IStreamProxyService proxyService,
+        IStreamUrlResolver streamUrlResolver,
+        IMediaCompositionFetcher mediaCompositionFetcher,
+        IServerApplicationHost appHost,
+        IMediaEncoder mediaEncoder)
+    {
+        _logger = logger;
+        _apiClientFactory = apiClientFactory;
+        _proxyService = proxyService;
+        _streamUrlResolver = streamUrlResolver;
+        _mediaCompositionFetcher = mediaCompositionFetcher;
+        _appHost = appHost;
+        _mediaEncoder = mediaEncoder;
+    }
+
+    private string GetDataFilePath()
+    {
+        var dataPath = Plugin.Instance?.DataFolderPath ?? Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "jellyfin", "plugins", "SRFPlay");
+        Directory.CreateDirectory(dataPath);
+        return Path.Combine(dataPath, "recordings.json");
+    }
+
+    private string GetRecordingOutputPath()
+    {
+        var config = Plugin.Instance?.Configuration;
+        var path = config?.RecordingOutputPath;
+        if (string.IsNullOrWhiteSpace(path))
+        {
+            path = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), "SRFRecordings");
+        }
+
+        Directory.CreateDirectory(path);
+        return path;
+    }
+
+    private string GetServerBaseUrl()
+    {
+        var config = Plugin.Instance?.Configuration;
+        if (config != null && !string.IsNullOrWhiteSpace(config.PublicServerUrl))
+        {
+            return config.PublicServerUrl.TrimEnd('/');
+        }
+
+        // For local ffmpeg access, use localhost directly
+        return "http://localhost:8096";
+    }
+
+    private async Task LoadRecordingsAsync()
+    {
+        if (_loaded)
+        {
+            return;
+        }
+
+        var filePath = GetDataFilePath();
+        if (File.Exists(filePath))
+        {
+            try
+            {
+                var json = await File.ReadAllTextAsync(filePath).ConfigureAwait(false);
+                _recordings = JsonSerializer.Deserialize<List<RecordingEntry>>(json) ?? new List<RecordingEntry>();
+                _logger.LogInformation("Loaded {Count} recording entries from {Path}", _recordings.Count, filePath);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "Failed to load recordings from {Path}", filePath);
+                _recordings = new List<RecordingEntry>();
+            }
+        }
+
+        _loaded = true;
+    }
+
+    private async Task SaveRecordingsAsync()
+    {
+        await _persistLock.WaitAsync().ConfigureAwait(false);
+        try
+        {
+            var filePath = GetDataFilePath();
+            var json = JsonSerializer.Serialize(_recordings, _jsonOptions);
+            await File.WriteAllTextAsync(filePath, json).ConfigureAwait(false);
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Failed to save recordings");
+        }
+        finally
+        {
+            _persistLock.Release();
+        }
+    }
+
+    /// <inheritdoc />
+    public async Task<IReadOnlyList<PlayV3TvProgram>> GetUpcomingScheduleAsync(CancellationToken cancellationToken)
+    {
+        var units = System.Enum.GetValues<Configuration.BusinessUnit>();
+
+        using var apiClient = _apiClientFactory.CreateClient();
+
+        // Aggregate sport livestreams across every business unit so the recordings
+        // page shows events from all languages.
+        var all = new List<PlayV3TvProgram>();
+        foreach (var unit in units)
+        {
+            var businessUnit = unit.ToString().ToLowerInvariant();
+            var livestreams = await apiClient.GetScheduledLivestreamsAsync(businessUnit, "SPORT", cancellationToken).ConfigureAwait(false);
+            if (livestreams != null)
+            {
+                all.AddRange(livestreams);
+            }
+        }
+
+        // Filter to only future/current livestreams that aren't blocked
+        return all
+            .Where(ls => ls.Blocked != true && (ls.ValidTo == null || ls.ValidTo.Value.ToUniversalTime() > DateTime.UtcNow))
+            .OrderBy(ls => ls.ValidFrom)
+            .ToList();
+    }
+
+    /// <inheritdoc />
+    public async Task<RecordingEntry> ScheduleRecordingAsync(string urn, CancellationToken cancellationToken)
+    {
+        await LoadRecordingsAsync().ConfigureAwait(false);
+
+        // Check if already scheduled
+        var existing = _recordings.FirstOrDefault(r => r.Urn == urn && r.State is RecordingState.Scheduled or RecordingState.WaitingForStream or RecordingState.Recording);
+        if (existing != null)
+        {
+            _logger.LogInformation("Recording already exists for URN {Urn} in state {State}", urn, existing.State);
+            return existing;
+        }
+
+        // Fetch metadata for the URN. The unit is encoded in the URN itself, so use that to
+        // query the right schedule regardless of which units are enabled.
+        var config = Plugin.Instance?.Configuration;
+        var businessUnit = ParseBusinessUnitFromUrn(urn)
+            ?? (config?.BusinessUnit ?? Configuration.BusinessUnit.SRF).ToString().ToLowerInvariant();
+
+        using var apiClient = _apiClientFactory.CreateClient();
+        var livestreams = await apiClient.GetScheduledLivestreamsAsync(businessUnit, "SPORT", cancellationToken).ConfigureAwait(false);
+        var program = livestreams?.FirstOrDefault(ls => ls.Urn == urn);
+
+        var entry = new RecordingEntry
+        {
+            Id = Guid.NewGuid().ToString("N"),
+            Urn = urn,
+            BusinessUnit = ParseBusinessUnitFromUrn(urn) ?? businessUnit,
+            Title = program?.Title ?? urn,
+            Description = program?.Lead ?? program?.Description,
+            ImageUrl = program?.ImageUrl,
+            ValidFrom = program?.ValidFrom,
+            ValidTo = program?.ValidTo,
+            State = RecordingState.Scheduled,
+            CreatedAt = DateTime.UtcNow
+        };
+
+        _recordings.Add(entry);
+        await SaveRecordingsAsync().ConfigureAwait(false);
+
+        _logger.LogInformation("Scheduled recording for '{Title}' (URN: {Urn}, starts: {ValidFrom})", entry.Title, urn, entry.ValidFrom);
+        return entry;
+    }
+
+    /// <summary>
+    /// Extracts the business unit from an SRF URN of the form "urn:&lt;bu&gt;:&lt;type&gt;:...".
+    /// </summary>
+    /// <param name="urn">The URN.</param>
+    /// <returns>The lowercase business unit, or null if it cannot be determined.</returns>
+    private static string? ParseBusinessUnitFromUrn(string urn)
+    {
+        if (string.IsNullOrEmpty(urn))
+        {
+            return null;
+        }
+
+        var parts = urn.Split(':');
+        return parts.Length >= 2 && !string.IsNullOrEmpty(parts[1])
+            ? parts[1].ToLowerInvariant()
+            : null;
+    }
+
+    /// <inheritdoc />
+    public bool CancelRecording(string recordingId)
+    {
+        var entry = _recordings.FirstOrDefault(r => r.Id == recordingId);
+        if (entry == null)
+        {
+            return false;
+        }
+
+        if (entry.State == RecordingState.Recording)
+        {
+            StopFfmpeg(recordingId);
+        }
+
+        entry.State = RecordingState.Cancelled;
+        entry.RecordingEndedAt = DateTime.UtcNow;
+        _ = SaveRecordingsAsync();
+
+        _logger.LogInformation("Cancelled recording '{Title}' ({Id})", entry.Title, recordingId);
+        return true;
+    }
+
+    /// <inheritdoc />
+    public bool StopRecording(string recordingId)
+    {
+        var entry = _recordings.FirstOrDefault(r => r.Id == recordingId && r.State == RecordingState.Recording);
+        if (entry == null)
+        {
+            return false;
+        }
+
+        StopFfmpeg(recordingId);
+
+        entry.State = RecordingState.Completed;
+        entry.RecordingEndedAt = DateTime.UtcNow;
+
+        if (entry.OutputPath != null && File.Exists(entry.OutputPath))
+        {
+            entry.FileSizeBytes = new FileInfo(entry.OutputPath).Length;
+        }
+
+        _ = SaveRecordingsAsync();
+
+        _logger.LogInformation("Stopped recording '{Title}' ({Id})", entry.Title, recordingId);
+        return true;
+    }
+
+    /// <inheritdoc />
+    public IReadOnlyList<RecordingEntry> GetRecordings(RecordingState? stateFilter)
+    {
+        // Ensure loaded synchronously for simple reads
+        if (!_loaded)
+        {
+            LoadRecordingsAsync().GetAwaiter().GetResult();
+        }
+
+        if (stateFilter.HasValue)
+        {
+            return _recordings.Where(r => r.State == stateFilter.Value).OrderByDescending(r => r.CreatedAt).ToList();
+        }
+
+        return _recordings.OrderByDescending(r => r.CreatedAt).ToList();
+    }
+
+    /// <inheritdoc />
+    public bool DeleteRecording(string recordingId, bool deleteFile)
+    {
+        var entry = _recordings.FirstOrDefault(r => r.Id == recordingId);
+        if (entry == null)
+        {
+            return false;
+        }
+
+        if (entry.State == RecordingState.Recording)
+        {
+            StopFfmpeg(recordingId);
+        }
+
+        if (deleteFile && !string.IsNullOrEmpty(entry.OutputPath) && File.Exists(entry.OutputPath))
+        {
+            try
+            {
+                File.Delete(entry.OutputPath);
+                _logger.LogInformation("Deleted recording file: {Path}", entry.OutputPath);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogWarning(ex, "Failed to delete recording file: {Path}", entry.OutputPath);
+            }
+        }
+
+        _recordings.Remove(entry);
+        _ = SaveRecordingsAsync();
+
+        _logger.LogInformation("Deleted recording entry '{Title}' ({Id})", entry.Title, recordingId);
+        return true;
+    }
+
+    /// <inheritdoc />
+    public async Task ProcessRecordingsAsync(CancellationToken cancellationToken)
+    {
+        // Prevent overlapping scheduler runs from spawning duplicate ffmpeg processes
+        if (!await _processLock.WaitAsync(0, CancellationToken.None).ConfigureAwait(false))
+        {
+            _logger.LogDebug("ProcessRecordingsAsync already running, skipping");
+            return;
+        }
+
+        try
+        {
+            await ProcessRecordingsCoreAsync(cancellationToken).ConfigureAwait(false);
+        }
+        finally
+        {
+            _processLock.Release();
+        }
+    }
+
+    private async Task ProcessRecordingsCoreAsync(CancellationToken cancellationToken)
+    {
+        await LoadRecordingsAsync().ConfigureAwait(false);
+
+        var now = DateTime.UtcNow;
+        var changed = false;
+
+        foreach (var entry in _recordings.ToList())
+        {
+            // Normalize ValidFrom/ValidTo to UTC for correct comparison
+            var validFromUtc = entry.ValidFrom.HasValue ? entry.ValidFrom.Value.ToUniversalTime() : (DateTime?)null;
+            var validToUtc = entry.ValidTo.HasValue ? entry.ValidTo.Value.ToUniversalTime() : (DateTime?)null;
+
+            switch (entry.State)
+            {
+                case RecordingState.Scheduled:
+                case RecordingState.WaitingForStream:
+                    // Check if it's time to start recording
+                    if (validFromUtc.HasValue && validFromUtc.Value <= now.AddMinutes(2))
+                    {
+                        _logger.LogInformation(
+                            "Time to start recording '{Title}': ValidFrom={ValidFrom} (UTC: {ValidFromUtc}), Now={Now}",
+                            entry.Title,
+                            entry.ValidFrom,
+                            validFromUtc,
+                            now);
+                        changed |= await TryStartRecordingAsync(entry, cancellationToken).ConfigureAwait(false);
+                    }
+
+                    break;
+
+                case RecordingState.Recording:
+                    // Check if recording should stop (ValidTo reached or process died)
+                    if (validToUtc.HasValue && validToUtc.Value <= now)
+                    {
+                        _logger.LogInformation("Recording '{Title}' reached ValidTo, stopping", entry.Title);
+                        StopFfmpeg(entry.Id);
+                        entry.State = RecordingState.Completed;
+                        entry.RecordingEndedAt = now;
+                        if (entry.OutputPath != null && File.Exists(entry.OutputPath))
+                        {
+                            entry.FileSizeBytes = new FileInfo(entry.OutputPath).Length;
+                        }
+
+                        changed = true;
+                    }
+                    else if (!_activeProcesses.ContainsKey(entry.Id))
+                    {
+                        // ffmpeg process died unexpectedly — try to restart
+                        _logger.LogWarning("ffmpeg process for '{Title}' is no longer running, attempting restart", entry.Title);
+                        changed |= await TryStartRecordingAsync(entry, cancellationToken).ConfigureAwait(false);
+                    }
+
+                    break;
+            }
+        }
+
+        if (changed)
+        {
+            await SaveRecordingsAsync().ConfigureAwait(false);
+        }
+    }
+
+    private async Task<bool> TryStartRecordingAsync(RecordingEntry entry, CancellationToken cancellationToken)
+    {
+        try
+        {
+            // Fetch the media composition to get the stream URL
+            var mediaComposition = await _mediaCompositionFetcher.GetMediaCompositionAsync(entry.Urn, cacheDurationOverride: 2, cancellationToken: cancellationToken).ConfigureAwait(false);
+            var chapter = mediaComposition?.ChapterList is { Count: > 0 } list ? list[0] : null;
+
+            if (chapter == null)
+            {
+                _logger.LogDebug("No chapter found for '{Title}', stream may not be live yet", entry.Title);
+                entry.State = RecordingState.WaitingForStream;
+                return true;
+            }
+
+            var config = Plugin.Instance?.Configuration;
+            var quality = config?.QualityPreference ?? Configuration.QualityPreference.Auto;
+            var streamUrl = _streamUrlResolver.GetStreamUrl(chapter, quality);
+
+            if (string.IsNullOrEmpty(streamUrl))
+            {
+                _logger.LogDebug("No stream URL available for '{Title}', waiting", entry.Title);
+                entry.State = RecordingState.WaitingForStream;
+                return true;
+            }
+
+            // Register the stream with the proxy so we can use the proxy URL
+            var itemId = $"rec_{entry.Id}";
+            var isLiveStream = chapter.Type == "SCHEDULED_LIVESTREAM" || UrnHelper.IsLivestreamUrn(entry.Urn);
+            _proxyService.RegisterStreamDeferred(itemId, streamUrl, entry.Urn, isLiveStream);
+
+            // Build proxy URL for ffmpeg (use localhost for local access)
+            var proxyUrl = $"{GetServerBaseUrl()}/Plugins/SRFPlay/Proxy/{itemId}/master.m3u8";
+
+            // Build output file path
+            var safeTitle = SanitizeFileName(entry.Title);
+            var timestamp = DateTime.Now.ToString("yyyy-MM-dd_HHmm", CultureInfo.InvariantCulture);
+            var outputPath = Path.Combine(GetRecordingOutputPath(), $"{safeTitle}_{timestamp}.mkv");
+            entry.OutputPath = outputPath;
+
+            // Start ffmpeg
+            StartFfmpeg(entry.Id, proxyUrl, outputPath);
+
+            entry.State = RecordingState.Recording;
+            entry.RecordingStartedAt = DateTime.UtcNow;
+
+            _logger.LogInformation("Started recording '{Title}' to {OutputPath}", entry.Title, outputPath);
+            return true;
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Failed to start recording '{Title}'", entry.Title);
+            entry.State = RecordingState.Failed;
+            entry.ErrorMessage = ex.Message;
+            return true;
+        }
+    }
+
+    private void StartFfmpeg(string recordingId, string inputUrl, string outputPath)
+    {
+        var process = new Process
+        {
+            StartInfo = new ProcessStartInfo
+            {
+                FileName = _mediaEncoder.EncoderPath,
+                Arguments = $"-y -i \"{inputUrl}\" -c copy -movflags +faststart \"{outputPath}\"",
+                UseShellExecute = false,
+                RedirectStandardInput = true,
+                RedirectStandardError = true,
+                CreateNoWindow = true
+            },
+            EnableRaisingEvents = true
+        };
+
+        process.ErrorDataReceived += (_, args) =>
+        {
+            if (!string.IsNullOrEmpty(args.Data))
+            {
+                _logger.LogDebug("ffmpeg [{RecordingId}]: {Data}", recordingId, args.Data);
+            }
+        };
+
+        process.Exited += (_, _) =>
+        {
+            _logger.LogInformation("ffmpeg process exited for recording {RecordingId} with code {ExitCode}", recordingId, process.ExitCode);
+            _activeProcesses.TryRemove(recordingId, out _);
+        };
+
+        process.Start();
+        process.BeginErrorReadLine();
+
+        _activeProcesses[recordingId] = process;
+        _logger.LogInformation("Started ffmpeg (PID {Pid}) for recording {RecordingId}: {Args}", process.Id, recordingId, process.StartInfo.Arguments);
+    }
+
+    private void StopFfmpeg(string recordingId)
+    {
+        if (_activeProcesses.TryRemove(recordingId, out var process))
+        {
+            try
+            {
+                if (!process.HasExited)
+                {
+                    // Send 'q' to ffmpeg stdin for graceful shutdown
+                    process.StandardInput.Write("q");
+                    process.StandardInput.Flush();
+
+                    if (!process.WaitForExit(10000))
+                    {
+                        _logger.LogWarning("ffmpeg did not exit gracefully for {RecordingId}, killing", recordingId);
+                        process.Kill(true);
+                    }
+                }
+
+                process.Dispose();
+            }
+            catch (Exception ex)
+            {
+                _logger.LogWarning(ex, "Error stopping ffmpeg for recording {RecordingId}", recordingId);
+            }
+        }
+    }
+
+    private static string SanitizeFileName(string name)
+    {
+        var invalid = Path.GetInvalidFileNameChars();
+        var sanitized = string.Join("_", name.Split(invalid, StringSplitOptions.RemoveEmptyEntries));
+        // Also replace spaces and other problematic chars
+        sanitized = Regex.Replace(sanitized, @"[\s]+", "_");
+        return sanitized.Length > 100 ? sanitized[..100] : sanitized;
+    }
+
+    /// <inheritdoc />
+    public void Dispose()
+    {
+        Dispose(true);
+        GC.SuppressFinalize(this);
+    }
+
+    /// <summary>
+    /// Releases resources.
+    /// </summary>
+    /// <param name="disposing">True to release managed resources.</param>
+    protected virtual void Dispose(bool disposing)
+    {
+        if (_disposed)
+        {
+            return;
+        }
+
+        if (disposing)
+        {
+            foreach (var kvp in _activeProcesses)
+            {
+                StopFfmpeg(kvp.Key);
+            }
+
+            _persistLock.Dispose();
+            _processLock.Dispose();
+        }
+
+        _disposed = true;
+    }
+}

Jellyfin.Plugin.SRFPlay/Services/ResumeCleanupService.cs

@@ -0,0 +1,302 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Threading;
+using Jellyfin.Data.Entities;
+using Jellyfin.Data.Enums;
+using Jellyfin.Plugin.SRFPlay.Api.Models;
+using Jellyfin.Plugin.SRFPlay.Configuration;
+using Jellyfin.Plugin.SRFPlay.Services.Interfaces;
+using Jellyfin.Plugin.SRFPlay.Utilities;
+using MediaBrowser.Controller.Dto;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Model.Entities;
+using Microsoft.Extensions.Logging;
+
+namespace Jellyfin.Plugin.SRFPlay.Services;
+
+/// <summary>
+/// Removes stale plugin-owned resume points from every user's "Continue Watching" row.
+/// </summary>
+public class ResumeCleanupService : IResumeCleanupService
+{
+    /// <summary>
+    /// Provider ID key stamped onto every item built from the SRG API.
+    /// </summary>
+    private const string SrfProviderId = "SRF";
+
+    private readonly ILogger<ResumeCleanupService> _logger;
+    private readonly ILibraryManager _libraryManager;
+    private readonly IUserManager _userManager;
+    private readonly IUserDataManager _userDataManager;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="ResumeCleanupService"/> class.
+    /// </summary>
+    /// <param name="loggerFactory">The logger factory.</param>
+    /// <param name="libraryManager">The library manager.</param>
+    /// <param name="userManager">The user manager.</param>
+    /// <param name="userDataManager">The user data manager.</param>
+    public ResumeCleanupService(
+        ILoggerFactory loggerFactory,
+        ILibraryManager libraryManager,
+        IUserManager userManager,
+        IUserDataManager userDataManager)
+    {
+        _logger = loggerFactory.CreateLogger<ResumeCleanupService>();
+        _libraryManager = libraryManager;
+        _userManager = userManager;
+        _userDataManager = userDataManager;
+    }
+
+    /// <inheritdoc />
+    public ResumeCleanupResult Cleanup(bool clearAll, CancellationToken cancellationToken)
+    {
+        var result = new ResumeCleanupResult();
+        var config = Plugin.Instance?.Configuration;
+
+        if (config == null)
+        {
+            _logger.LogWarning("Plugin configuration not available - skipping resume point cleanup");
+            return result;
+        }
+
+        if (!clearAll && !config.CleanUpResumePoints)
+        {
+            _logger.LogDebug("Resume point cleanup is disabled in configuration");
+            return result;
+        }
+
+        var channelIds = GetPluginChannelIds();
+
+        foreach (var user in _userManager.Users)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+            result.UsersChecked++;
+
+            var query = new InternalItemsQuery(user)
+            {
+                IsResumable = true,
+                Recursive = true,
+                EnableTotalRecordCount = false,
+                DtoOptions = new DtoOptions(false)
+            };
+
+            foreach (var item in _libraryManager.GetItemList(query))
+            {
+                cancellationToken.ThrowIfCancellationRequested();
+
+                if (!IsPluginItem(item, channelIds))
+                {
+                    continue;
+                }
+
+                result.Inspected++;
+
+                var userData = _userDataManager.GetUserData(user, item);
+                if (userData == null || userData.PlaybackPositionTicks <= 0)
+                {
+                    continue;
+                }
+
+                var reason = clearAll ? "clear all" : GetStaleReason(item, userData, config);
+                if (reason == null)
+                {
+                    continue;
+                }
+
+                if (ClearResumePoint(item, user, userData, reason))
+                {
+                    result.Cleared++;
+                    result.ClearedByReason.TryGetValue(reason, out var count);
+                    result.ClearedByReason[reason] = count + 1;
+                }
+            }
+        }
+
+        _logger.LogInformation(
+            "Resume point cleanup finished: {Cleared} of {Inspected} SRF Play resume points cleared across {Users} user(s)",
+            result.Cleared,
+            result.Inspected,
+            result.UsersChecked);
+
+        return result;
+    }
+
+    /// <inheritdoc />
+    public int ClearResumePoint(BaseItem item, IEnumerable<User> users, string reason)
+    {
+        ArgumentNullException.ThrowIfNull(item);
+        ArgumentNullException.ThrowIfNull(users);
+
+        var cleared = 0;
+
+        foreach (var user in users)
+        {
+            var userData = _userDataManager.GetUserData(user, item);
+            if (userData == null || userData.PlaybackPositionTicks <= 0)
+            {
+                continue;
+            }
+
+            if (ClearResumePoint(item, user, userData, reason))
+            {
+                cleared++;
+            }
+        }
+
+        return cleared;
+    }
+
+    /// <inheritdoc />
+    public bool IsPluginItem(BaseItem item)
+    {
+        return IsPluginItem(item, GetPluginChannelIds());
+    }
+
+    /// <inheritdoc />
+    public int ClearLiveStreamResumePoint(BaseItem item, IEnumerable<User> users)
+    {
+        if (item == null || Plugin.Instance?.Configuration.ClearLiveStreamResumePoints != true)
+        {
+            return 0;
+        }
+
+        // Only the URN heuristic here - the item is already known, and re-querying the channel
+        // list on every playback stop would be wasteful.
+        if (!UrnHelper.IsLivestreamUrn(item.ProviderIds.GetValueOrDefault(SrfProviderId)))
+        {
+            return 0;
+        }
+
+        return ClearResumePoint(item, users, "livestream stopped");
+    }
+
+    /// <summary>
+    /// Determines whether an item belongs to one of this plugin's channels.
+    /// </summary>
+    /// <param name="item">The item to test.</param>
+    /// <param name="channelIds">The set of channel IDs owned by this plugin.</param>
+    /// <returns>True if the item is owned by this plugin.</returns>
+    private static bool IsPluginItem(BaseItem item, HashSet<Guid> channelIds)
+    {
+        if (item == null)
+        {
+            return false;
+        }
+
+        // API-sourced content carries the URN as a provider ID. Recordings do not, so fall back
+        // to the owning channel, which also covers any item shape added later.
+        return item.ProviderIds.ContainsKey(SrfProviderId)
+            || (!item.ChannelId.Equals(Guid.Empty) && channelIds.Contains(item.ChannelId));
+    }
+
+    /// <summary>
+    /// Resolves the IDs of the channel entries created by this plugin, one per business unit.
+    /// </summary>
+    /// <returns>The set of channel IDs, empty if the channels have not been scanned yet.</returns>
+    private HashSet<Guid> GetPluginChannelIds()
+    {
+        // SrgChannelBase names every channel "{unit} Play".
+        var names = Enum.GetNames<BusinessUnit>()
+            .Select(unit => unit + " Play")
+            .ToHashSet(StringComparer.OrdinalIgnoreCase);
+
+        var channels = _libraryManager.GetItemList(new InternalItemsQuery
+        {
+            IncludeItemTypes = new[] { BaseItemKind.Channel },
+            EnableTotalRecordCount = false,
+            DtoOptions = new DtoOptions(false)
+        });
+
+        return channels
+            .Where(channel => channel.Name != null && names.Contains(channel.Name))
+            .Select(channel => channel.Id)
+            .ToHashSet();
+    }
+
+    /// <summary>
+    /// Decides whether a resume point is stale, and why.
+    /// </summary>
+    /// <param name="item">The item the resume point belongs to.</param>
+    /// <param name="userData">The user data holding the resume position.</param>
+    /// <param name="config">The plugin configuration supplying the thresholds.</param>
+    /// <returns>A short reason string, or null when the resume point should be kept.</returns>
+    private static string? GetStaleReason(BaseItem item, UserItemData userData, PluginConfiguration config)
+    {
+        // A livestream has no meaningful position to return to: by the time the user comes back
+        // the broadcast has moved on or ended. These are the entries that pile up the fastest.
+        if (config.ClearLiveStreamResumePoints
+            && UrnHelper.IsLivestreamUrn(item.ProviderIds.GetValueOrDefault(SrfProviderId)))
+        {
+            return "livestream";
+        }
+
+        if (config.ResumePointMaxAgeDays > 0
+            && userData.LastPlayedDate.HasValue
+            && userData.LastPlayedDate.Value.ToUniversalTime() < DateTime.UtcNow.AddDays(-config.ResumePointMaxAgeDays))
+        {
+            return "older than " + config.ResumePointMaxAgeDays.ToString(CultureInfo.InvariantCulture) + " days";
+        }
+
+        if (config.ResumePointMinPositionSeconds > 0
+            && userData.PlaybackPositionTicks <= TimeSpan.FromSeconds(config.ResumePointMinPositionSeconds).Ticks)
+        {
+            return "barely started";
+        }
+
+        // Runtime is unknown for live and for some API items; without it there is nothing to
+        // compare the position against, so leave the resume point alone.
+        if (config.ResumePointCompletedPercent > 0
+            && item.RunTimeTicks.HasValue
+            && item.RunTimeTicks.Value > 0)
+        {
+            var watchedPercent = userData.PlaybackPositionTicks * 100.0 / item.RunTimeTicks.Value;
+            if (watchedPercent >= config.ResumePointCompletedPercent)
+            {
+                return "watched to the end";
+            }
+        }
+
+        return null;
+    }
+
+    /// <summary>
+    /// Zeroes the resume position, which removes the item from "Continue Watching" while
+    /// leaving it unwatched so it can still be played again from the start.
+    /// </summary>
+    /// <param name="item">The item to clear.</param>
+    /// <param name="user">The user to clear it for.</param>
+    /// <param name="userData">The user data to update.</param>
+    /// <param name="reason">A short reason, logged for traceability.</param>
+    /// <returns>True if the resume point was cleared.</returns>
+    private bool ClearResumePoint(BaseItem item, User user, UserItemData userData, string reason)
+    {
+        try
+        {
+            userData.PlaybackPositionTicks = 0;
+
+            _userDataManager.SaveUserData(
+                user,
+                item,
+                userData,
+                UserDataSaveReason.UpdateUserData,
+                CancellationToken.None);
+
+            _logger.LogInformation(
+                "Cleared resume point for '{Name}' (user {User}, reason: {Reason})",
+                item.Name,
+                user.Username,
+                reason);
+
+            return true;
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Failed to clear resume point for '{Name}'", item.Name);
+            return false;
+        }
+    }
+}

Jellyfin.Plugin.SRFPlay/Services/StreamUrlResolver.cs

@@ -0,0 +1,306 @@
+using System;
+using System.Linq;
+using System.Net.Http;
+using System.Text.Json;
+using System.Threading;
+using System.Threading.Tasks;
+using Jellyfin.Plugin.SRFPlay.Api.Models;
+using Jellyfin.Plugin.SRFPlay.Configuration;
+using Jellyfin.Plugin.SRFPlay.Constants;
+using Jellyfin.Plugin.SRFPlay.Services.Interfaces;
+using MediaBrowser.Common.Net;
+using Microsoft.Extensions.Logging;
+
+namespace Jellyfin.Plugin.SRFPlay.Services;
+
+/// <summary>
+/// Service for resolving stream URLs from media composition resources.
+/// </summary>
+public class StreamUrlResolver : IStreamUrlResolver
+{
+    private readonly ILogger<StreamUrlResolver> _logger;
+    private readonly IHttpClientFactory _httpClientFactory;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="StreamUrlResolver"/> class.
+    /// </summary>
+    /// <param name="logger">The logger instance.</param>
+    /// <param name="httpClientFactory">The HTTP client factory.</param>
+    public StreamUrlResolver(ILogger<StreamUrlResolver> logger, IHttpClientFactory httpClientFactory)
+    {
+        _logger = logger;
+        _httpClientFactory = httpClientFactory;
+    }
+
+    /// <summary>
+    /// Gets the best stream URL from a chapter based on quality preference.
+    /// </summary>
+    /// <param name="chapter">The chapter containing resources.</param>
+    /// <param name="qualityPreference">The quality preference.</param>
+    /// <returns>The stream URL, or null if no suitable stream found.</returns>
+    public string? GetStreamUrl(Chapter chapter, QualityPreference qualityPreference)
+    {
+        if (chapter?.ResourceList == null || chapter.ResourceList.Count == 0)
+        {
+            _logger.LogWarning("No resources found for chapter: {ChapterId}", chapter?.Id);
+            return null;
+        }
+
+        _logger.LogInformation(
+            "Processing chapter {ChapterId} with {ResourceCount} resources",
+            chapter.Id,
+            chapter.ResourceList.Count);
+
+        // Filter out DRM-protected content
+        var nonDrmResources = chapter.ResourceList
+            .Where(r => r.IsPlayable)
+            .ToList();
+
+        _logger.LogInformation(
+            "Chapter {ChapterId}: Total resources={Total}, Non-DRM resources={NonDrm}",
+            chapter.Id,
+            chapter.ResourceList.Count,
+            nonDrmResources.Count);
+
+        if (nonDrmResources.Count == 0)
+        {
+            _logger.LogWarning("All resources for chapter {ChapterId} require DRM", chapter.Id);
+            // Log what DRM types are present
+            foreach (var resource in chapter.ResourceList)
+            {
+                _logger.LogDebug(
+                    "DRM resource: Protocol={Protocol}, Streaming={Streaming}, DRM={Drm}",
+                    resource.Protocol,
+                    resource.Streaming,
+                    resource.DrmList);
+            }
+
+            return null;
+        }
+
+        // Prefer HLS protocol
+        var hlsResources = nonDrmResources
+            .Where(r => string.Equals(r.Protocol, "HLS", StringComparison.OrdinalIgnoreCase) ||
+                       string.Equals(r.Streaming, "HLS", StringComparison.OrdinalIgnoreCase) ||
+                       r.Url.Contains(".m3u8", StringComparison.OrdinalIgnoreCase))
+            .ToList();
+
+        _logger.LogInformation(
+            "Chapter {ChapterId}: HLS resources found={HlsCount}",
+            chapter.Id,
+            hlsResources.Count);
+
+        // Log all HLS resources with their quality info to help debug quality selection
+        foreach (var resource in hlsResources)
+        {
+            _logger.LogInformation(
+                "Available HLS resource - Quality={Quality}, Protocol={Protocol}, Streaming={Streaming}, URL={Url}",
+                resource.Quality ?? "NULL",
+                resource.Protocol ?? "NULL",
+                resource.Streaming ?? "NULL",
+                resource.Url);
+        }
+
+        if (hlsResources.Count == 0)
+        {
+            _logger.LogWarning("No HLS resources found for chapter: {ChapterId}", chapter.Id);
+            // Log available protocols
+            foreach (var resource in nonDrmResources)
+            {
+                _logger.LogDebug(
+                    "Non-HLS resource: Protocol={Protocol}, Streaming={Streaming}, URL={Url}",
+                    resource.Protocol,
+                    resource.Streaming,
+                    resource.Url);
+            }
+
+            // Fallback to any available non-DRM resource
+            var fallbackResource = nonDrmResources.FirstOrDefault();
+            if (fallbackResource != null)
+            {
+                _logger.LogInformation(
+                    "Using fallback resource for chapter {ChapterId}: {Url}",
+                    chapter.Id,
+                    fallbackResource.Url);
+            }
+
+            return fallbackResource?.Url;
+        }
+
+        // Select based on quality preference
+        _logger.LogInformation(
+            "Selecting stream with quality preference: {QualityPreference}",
+            qualityPreference);
+
+        Resource? selectedResource = qualityPreference switch
+        {
+            QualityPreference.HD => SelectHDResource(hlsResources) ?? SelectBestAvailableResource(hlsResources),
+            QualityPreference.SD => SelectSDResource(hlsResources) ?? SelectBestAvailableResource(hlsResources),
+            QualityPreference.Auto => hlsResources.FirstOrDefault(),
+            _ => hlsResources.FirstOrDefault()
+        };
+
+        if (selectedResource != null)
+        {
+            _logger.LogDebug(
+                "Selected stream for chapter {ChapterId}: Quality={Quality}, Protocol={Protocol}, URL={Url}",
+                chapter.Id,
+                selectedResource.Quality ?? "NULL",
+                selectedResource.Protocol,
+                selectedResource.Url);
+            return selectedResource.Url;
+        }
+
+        _logger.LogWarning("Could not select appropriate stream for chapter: {ChapterId}", chapter.Id);
+        return null;
+    }
+
+    /// <summary>
+    /// Checks if a chapter has non-DRM playable content.
+    /// </summary>
+    /// <param name="chapter">The chapter to check.</param>
+    /// <returns>True if playable content is available.</returns>
+    public bool HasPlayableContent(Chapter chapter)
+    {
+        if (chapter?.ResourceList == null || chapter.ResourceList.Count == 0)
+        {
+            _logger.LogWarning(
+                "Chapter {ChapterId}: ResourceList is null or empty. ResourceList count: {Count}, ResourceList type: {Type}",
+                chapter?.Id ?? "null",
+                chapter?.ResourceList?.Count ?? -1,
+                chapter?.ResourceList?.GetType().Name ?? "null");
+            return false;
+        }
+
+        _logger.LogInformation(
+            "Chapter {ChapterId}: Found {ResourceCount} resources",
+            chapter.Id,
+            chapter.ResourceList.Count);
+
+        foreach (var resource in chapter.ResourceList)
+        {
+            var urlPreview = resource.Url == null ? "null" : resource.Url.AsSpan(0, Math.Min(60, resource.Url.Length)).ToString() + "...";
+            _logger.LogDebug(
+                "Resource - URL: {Url}, Quality: {Quality}, DrmList: {DrmList}, DrmList type: {DrmListType}",
+                urlPreview,
+                resource.Quality,
+                resource.DrmList?.ToString() ?? "null",
+                resource.DrmList?.GetType().Name ?? "null");
+        }
+
+        var hasPlayable = chapter.ResourceList.Any(r => r.IsPlayable);
+        _logger.LogInformation("Chapter {ChapterId}: Has playable content: {HasPlayable}", chapter.Id, hasPlayable);
+        return hasPlayable;
+    }
+
+    /// <summary>
+    /// Checks if content is expired based on ValidTo date.
+    /// </summary>
+    /// <param name="chapter">The chapter to check.</param>
+    /// <returns>True if the content is expired.</returns>
+    public bool IsContentExpired(Chapter chapter)
+    {
+        if (chapter?.ValidTo == null)
+        {
+            return false;
+        }
+
+        return DateTime.UtcNow > chapter.ValidTo.Value.ToUniversalTime();
+    }
+
+    private Resource? SelectHDResource(System.Collections.Generic.List<Resource> resources)
+    {
+        return resources.FirstOrDefault(r =>
+            string.Equals(r.Quality, "HD", StringComparison.OrdinalIgnoreCase) ||
+            string.Equals(r.Quality, "1080", StringComparison.OrdinalIgnoreCase) ||
+            string.Equals(r.Quality, "720", StringComparison.OrdinalIgnoreCase));
+    }
+
+    private Resource? SelectSDResource(System.Collections.Generic.List<Resource> resources)
+    {
+        return resources.FirstOrDefault(r =>
+            string.Equals(r.Quality, "SD", StringComparison.OrdinalIgnoreCase) ||
+            string.Equals(r.Quality, "480", StringComparison.OrdinalIgnoreCase) ||
+            string.Equals(r.Quality, "360", StringComparison.OrdinalIgnoreCase));
+    }
+
+    private Resource? SelectBestAvailableResource(System.Collections.Generic.List<Resource> resources)
+    {
+        // Try HD first
+        var hdResource = SelectHDResource(resources);
+        if (hdResource != null)
+        {
+            return hdResource;
+        }
+
+        // Fall back to SD
+        var sdResource = SelectSDResource(resources);
+        if (sdResource != null)
+        {
+            return sdResource;
+        }
+
+        // Return first available
+        return resources.FirstOrDefault();
+    }
+
+    /// <summary>
+    /// Authenticates a stream URL by fetching an Akamai token.
+    /// Based on the Kodi addon implementation.
+    /// </summary>
+    /// <param name="streamUrl">The unauthenticated stream URL.</param>
+    /// <param name="cancellationToken">Cancellation token.</param>
+    /// <returns>The authenticated stream URL with token.</returns>
+    public async Task<string> GetAuthenticatedStreamUrlAsync(string streamUrl, CancellationToken cancellationToken = default)
+    {
+        try
+        {
+            // Parse the stream URL to extract path components
+            var uri = new Uri(streamUrl);
+            var pathSegments = uri.AbsolutePath.Split('/', StringSplitOptions.RemoveEmptyEntries);
+
+            if (pathSegments.Length < 2)
+            {
+                _logger.LogWarning("Stream URL has insufficient path segments for authentication: {Url}", streamUrl);
+                return streamUrl;
+            }
+
+            // Build ACL path: /{segment1}/{segment2}/*
+            var aclPath = $"/{pathSegments[0]}/{pathSegments[1]}/*";
+            var tokenUrl = $"{ApiEndpoints.AkamaiTokenEndpoint}?acl={Uri.EscapeDataString(aclPath)}";
+
+            _logger.LogDebug("Fetching auth token from: {TokenUrl}", tokenUrl);
+
+            using var httpClient = _httpClientFactory.CreateClient(NamedClient.Default);
+            var response = await httpClient.GetAsync(tokenUrl, cancellationToken).ConfigureAwait(false);
+            response.EnsureSuccessStatusCode();
+
+            var jsonContent = await response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+            var tokenResponse = JsonSerializer.Deserialize<JsonElement>(jsonContent);
+
+            // Extract authparams from response
+            if (tokenResponse.TryGetProperty("token", out var token) &&
+                token.TryGetProperty("authparams", out var authParams))
+            {
+                var authParamsValue = authParams.GetString();
+                if (!string.IsNullOrEmpty(authParamsValue))
+                {
+                    // Append auth params to original URL
+                    var separator = streamUrl.Contains('?', StringComparison.Ordinal) ? "&" : "?";
+                    var authenticatedUrl = $"{streamUrl}{separator}{authParamsValue}";
+
+                    _logger.LogInformation("Successfully authenticated stream URL");
+                    return authenticatedUrl;
+                }
+            }
+
+            _logger.LogWarning("No auth params found in token response, returning original URL");
+            return streamUrl;
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Failed to authenticate stream URL: {Url}", streamUrl);
+            return streamUrl; // Return original URL as fallback
+        }
+    }
+}

Jellyfin.Plugin.SRFPlay/Utilities/Extensions.cs

@@ -0,0 +1,19 @@
+using Jellyfin.Plugin.SRFPlay.Configuration;
+
+namespace Jellyfin.Plugin.SRFPlay.Utilities;
+
+/// <summary>
+/// Extension methods for common plugin operations.
+/// </summary>
+public static class Extensions
+{
+    /// <summary>
+    /// Converts the BusinessUnit enum to its lowercase string representation.
+    /// </summary>
+    /// <param name="businessUnit">The business unit.</param>
+    /// <returns>The lowercase string representation.</returns>
+    public static string ToLowerString(this BusinessUnit businessUnit)
+    {
+        return businessUnit.ToString().ToLowerInvariant();
+    }
+}

Jellyfin.Plugin.SRFPlay/Utilities/MimeTypeHelper.cs

@@ -0,0 +1,74 @@
+using System;
+
+namespace Jellyfin.Plugin.SRFPlay.Utilities;
+
+/// <summary>
+/// Helper class for determining MIME content types.
+/// </summary>
+public static class MimeTypeHelper
+{
+    /// <summary>
+    /// Gets the MIME content type for an image based on URL or file extension.
+    /// </summary>
+    /// <param name="url">The image URL.</param>
+    /// <returns>The MIME content type, defaulting to "image/jpeg" for SRF images.</returns>
+    public static string GetImageContentType(string? url)
+    {
+        if (string.IsNullOrEmpty(url))
+        {
+            return "image/jpeg";
+        }
+
+        var uri = new Uri(url);
+        var path = uri.AbsolutePath.ToLowerInvariant();
+
+        if (path.EndsWith(".png", StringComparison.Ordinal))
+        {
+            return "image/png";
+        }
+
+        if (path.EndsWith(".gif", StringComparison.Ordinal))
+        {
+            return "image/gif";
+        }
+
+        if (path.EndsWith(".webp", StringComparison.Ordinal))
+        {
+            return "image/webp";
+        }
+
+        if (path.EndsWith(".jpg", StringComparison.Ordinal) || path.EndsWith(".jpeg", StringComparison.Ordinal))
+        {
+            return "image/jpeg";
+        }
+
+        // Default to JPEG for SRF images (most common)
+        return "image/jpeg";
+    }
+
+    /// <summary>
+    /// Gets the MIME content type for a media segment based on file extension.
+    /// </summary>
+    /// <param name="path">The segment path or filename.</param>
+    /// <returns>The MIME content type.</returns>
+    public static string GetSegmentContentType(string path)
+    {
+        if (path.EndsWith(".ts", StringComparison.OrdinalIgnoreCase))
+        {
+            return "video/MP2T";
+        }
+
+        if (path.EndsWith(".mp4", StringComparison.OrdinalIgnoreCase) ||
+            path.EndsWith(".m4s", StringComparison.OrdinalIgnoreCase))
+        {
+            return "video/mp4";
+        }
+
+        if (path.EndsWith(".aac", StringComparison.OrdinalIgnoreCase))
+        {
+            return "audio/aac";
+        }
+
+        return "application/octet-stream";
+    }
+}

Jellyfin.Plugin.SRFPlay/Utilities/PlaceholderImageGenerator.cs

@@ -0,0 +1,141 @@
+using System.IO;
+using SkiaSharp;
+
+namespace Jellyfin.Plugin.SRFPlay.Utilities;
+
+/// <summary>
+/// Generates placeholder images for content without thumbnails.
+/// </summary>
+public static class PlaceholderImageGenerator
+{
+    private const int Width = 640;
+    private const int Height = 360; // 16:9 aspect ratio
+
+    /// <summary>
+    /// Generates a placeholder image with the given text centered.
+    /// </summary>
+    /// <param name="text">The text to display (typically channel/show name).</param>
+    /// <returns>A memory stream containing the PNG image.</returns>
+    public static MemoryStream GeneratePlaceholder(string text)
+    {
+        using var surface = SKSurface.Create(new SKImageInfo(Width, Height));
+        var canvas = surface.Canvas;
+
+        // Dark gradient background
+        using var backgroundPaint = new SKPaint();
+        using var shader = SKShader.CreateLinearGradient(
+            new SKPoint(0, 0),
+            new SKPoint(Width, Height),
+            new[] { new SKColor(45, 45, 48), new SKColor(28, 28, 30) },
+            null,
+            SKShaderTileMode.Clamp);
+        backgroundPaint.Shader = shader;
+        canvas.DrawRect(0, 0, Width, Height, backgroundPaint);
+
+        // Text
+        using var textPaint = new SKPaint
+        {
+            Color = SKColors.White,
+            IsAntialias = true,
+            TextAlign = SKTextAlign.Center,
+            Typeface = SKTypeface.FromFamilyName("Arial", SKFontStyle.Bold)
+        };
+
+        // Calculate font size and wrap text if needed
+        float fontSize = 48;
+        textPaint.TextSize = fontSize;
+        var maxWidth = Width * 0.85f;
+        var maxHeight = Height * 0.8f;
+
+        var lines = WrapText(text, textPaint, maxWidth, maxHeight, ref fontSize);
+
+        // Draw each line centered
+        var lineHeight = fontSize * 1.2f;
+        var totalHeight = lines.Count * lineHeight;
+        var startY = ((Height - totalHeight) / 2) + fontSize;
+
+        foreach (var line in lines)
+        {
+            canvas.DrawText(line, Width / 2, startY, textPaint);
+            startY += lineHeight;
+        }
+
+        // Encode to PNG
+        using var image = surface.Snapshot();
+        using var data = image.Encode(SKEncodedImageFormat.Png, 100);
+
+        var stream = new MemoryStream();
+        data.SaveTo(stream);
+        stream.Position = 0;
+        return stream;
+    }
+
+    /// <summary>
+    /// Wraps text to fit within the specified width and height constraints.
+    /// </summary>
+    /// <param name="text">The text to wrap.</param>
+    /// <param name="paint">The paint to use for measuring.</param>
+    /// <param name="maxWidth">Maximum width for each line.</param>
+    /// <param name="maxHeight">Maximum total height.</param>
+    /// <param name="fontSize">Font size (will be adjusted if needed).</param>
+    /// <returns>List of text lines.</returns>
+    private static System.Collections.Generic.List<string> WrapText(
+        string text,
+        SKPaint paint,
+        float maxWidth,
+        float maxHeight,
+        ref float fontSize)
+    {
+        const float minFontSize = 20;
+        var words = text.Split(' ');
+        var lines = new System.Collections.Generic.List<string>();
+
+        while (fontSize >= minFontSize)
+        {
+            paint.TextSize = fontSize;
+            lines.Clear();
+
+            var currentLine = string.Empty;
+            foreach (var word in words)
+            {
+                var testLine = string.IsNullOrEmpty(currentLine) ? word : $"{currentLine} {word}";
+                var testWidth = paint.MeasureText(testLine);
+
+                if (testWidth > maxWidth && !string.IsNullOrEmpty(currentLine))
+                {
+                    lines.Add(currentLine);
+                    currentLine = word;
+                }
+                else
+                {
+                    currentLine = testLine;
+                }
+            }
+
+            if (!string.IsNullOrEmpty(currentLine))
+            {
+                lines.Add(currentLine);
+            }
+
+            // Check if total height fits
+            var lineHeight = fontSize * 1.2f;
+            var totalHeight = lines.Count * lineHeight;
+
+            if (totalHeight <= maxHeight)
+            {
+                break;
+            }
+
+            // Reduce font size and try again
+            fontSize -= 2;
+        }
+
+        // If still doesn't fit, just return what we have
+        if (lines.Count == 0)
+        {
+            lines.Add(text);
+        }
+
+        return lines;
+    }
+}

Jellyfin.Plugin.SRFPlay/Utilities/UrnHelper.cs

@@ -0,0 +1,40 @@
+using System;
+using System.Security.Cryptography;
+using System.Text;
+
+namespace Jellyfin.Plugin.SRFPlay.Utilities;
+
+/// <summary>
+/// Helper class for URN-related operations.
+/// </summary>
+public static class UrnHelper
+{
+    /// <summary>
+    /// Generates a deterministic GUID from a URN.
+    /// This ensures the same URN always produces the same GUID.
+    /// MD5 is used for non-cryptographic purposes only (generating stable IDs).
+    /// </summary>
+    /// <param name="urn">The URN to convert.</param>
+    /// <returns>A deterministic GUID string.</returns>
+#pragma warning disable CA5351 // MD5 is used for non-cryptographic purposes (ID generation)
+    public static string ToGuid(string urn)
+    {
+        var hash = MD5.HashData(Encoding.UTF8.GetBytes(urn));
+        var guid = new Guid(hash);
+        return guid.ToString();
+    }
+#pragma warning restore CA5351
+
+    /// <summary>
+    /// Determines whether a URN refers to a livestream (scheduled or continuous).
+    /// This is a URN-only heuristic that needs no API call, so it stays usable long after
+    /// the broadcast has ended and the media composition is no longer worth fetching.
+    /// </summary>
+    /// <param name="urn">The URN to inspect. May be null or empty.</param>
+    /// <returns>True if the URN identifies livestream content.</returns>
+    public static bool IsLivestreamUrn(string? urn)
+    {
+        return !string.IsNullOrEmpty(urn)
+            && urn.Contains("livestream", StringComparison.OrdinalIgnoreCase);
+    }
+}

Jellyfin.Plugin.Template.sln

@@ -1,15 +0,0 @@
-Microsoft Visual Studio Solution File, Format Version 12.00
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Jellyfin.Plugin.Template", "Jellyfin.Plugin.Template\Jellyfin.Plugin.Template.csproj", "{D921B930-CF91-406F-ACBC-08914DCD0D34}"
-EndProject
-Global
-	GlobalSection(SolutionConfigurationPlatforms) = preSolution
-		Debug|Any CPU = Debug|Any CPU
-		Release|Any CPU = Release|Any CPU
-	EndGlobalSection
-	GlobalSection(ProjectConfigurationPlatforms) = postSolution
-		{D921B930-CF91-406F-ACBC-08914DCD0D34}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{D921B930-CF91-406F-ACBC-08914DCD0D34}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{D921B930-CF91-406F-ACBC-08914DCD0D34}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{D921B930-CF91-406F-ACBC-08914DCD0D34}.Release|Any CPU.Build.0 = Release|Any CPU
-	EndGlobalSection
-EndGlobal

Jellyfin.Plugin.Template/Configuration/PluginConfiguration.cs

@@ -1,57 +0,0 @@
-using MediaBrowser.Model.Plugins;
-
-namespace Jellyfin.Plugin.Template.Configuration;
-
-/// <summary>
-/// The configuration options.
-/// </summary>
-public enum SomeOptions
-{
-    /// <summary>
-    /// Option one.
-    /// </summary>
-    OneOption,
-
-    /// <summary>
-    /// Second option.
-    /// </summary>
-    AnotherOption
-}
-
-/// <summary>
-/// Plugin configuration.
-/// </summary>
-public class PluginConfiguration : BasePluginConfiguration
-{
-    /// <summary>
-    /// Initializes a new instance of the <see cref="PluginConfiguration"/> class.
-    /// </summary>
-    public PluginConfiguration()
-    {
-        // set default options here
-        Options = SomeOptions.AnotherOption;
-        TrueFalseSetting = true;
-        AnInteger = 2;
-        AString = "string";
-    }
-
-    /// <summary>
-    /// Gets or sets a value indicating whether some true or false setting is enabled..
-    /// </summary>
-    public bool TrueFalseSetting { get; set; }
-
-    /// <summary>
-    /// Gets or sets an integer setting.
-    /// </summary>
-    public int AnInteger { get; set; }
-
-    /// <summary>
-    /// Gets or sets a string setting.
-    /// </summary>
-    public string AString { get; set; }
-
-    /// <summary>
-    /// Gets or sets an enum option.
-    /// </summary>
-    public SomeOptions Options { get; set; }
-}

Jellyfin.Plugin.Template/Configuration/configPage.html

@@ -1,79 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-<head>
-    <meta charset="utf-8">
-    <title>Template</title>
-</head>
-<body>
-    <div id="TemplateConfigPage" data-role="page" class="page type-interior pluginConfigurationPage" data-require="emby-input,emby-button,emby-select,emby-checkbox">
-        <div data-role="content">
-            <div class="content-primary">
-                <form id="TemplateConfigForm">
-                    <div class="selectContainer">
-                        <label class="selectLabel" for="Options">Several Options</label>
-                        <select is="emby-select" id="Options" name="Options" class="emby-select-withcolor emby-select">
-                            <option id="optOneOption" value="OneOption">One Option</option>
-                            <option id="optAnotherOption" value="AnotherOption">Another Option</option>
-                        </select>
-                    </div>
-                    <div class="inputContainer">
-                        <label class="inputLabel inputLabelUnfocused" for="AnInteger">An Integer</label>
-                        <input id="AnInteger" name="AnInteger" type="number" is="emby-input" min="0" />
-                        <div class="fieldDescription">A Description</div>
-                    </div>
-                    <div class="checkboxContainer checkboxContainer-withDescription">
-                        <label class="emby-checkbox-label">
-                            <input id="TrueFalseSetting" name="TrueFalseCheckBox" type="checkbox" is="emby-checkbox" />
-                            <span>A Checkbox</span>
-                        </label>
-                    </div>
-                    <div class="inputContainer">
-                        <label class="inputLabel inputLabelUnfocused" for="AString">A String</label>
-                        <input id="AString" name="AString" type="text" is="emby-input" />
-                        <div class="fieldDescription">Another Description</div>
-                    </div>
-                    <div>
-                        <button is="emby-button" type="submit" class="raised button-submit block emby-button">
-                            <span>Save</span>
-                        </button>
-                    </div>
-                </form>
-            </div>
-        </div>
-        <script type="text/javascript">
-            var TemplateConfig = {
-                pluginUniqueId: 'eb5d7894-8eef-4b36-aa6f-5d124e828ce1'
-            };
-
-            document.querySelector('#TemplateConfigPage')
-                .addEventListener('pageshow', function() {
-                    Dashboard.showLoadingMsg();
-                    ApiClient.getPluginConfiguration(TemplateConfig.pluginUniqueId).then(function (config) {
-                        document.querySelector('#Options').value = config.Options;
-                        document.querySelector('#AnInteger').value = config.AnInteger;
-                        document.querySelector('#TrueFalseSetting').checked = config.TrueFalseSetting;
-                        document.querySelector('#AString').value = config.AString;
-                        Dashboard.hideLoadingMsg();
-                    });
-                });
-
-            document.querySelector('#TemplateConfigForm')
-                .addEventListener('submit', function(e) {
-                Dashboard.showLoadingMsg();
-                ApiClient.getPluginConfiguration(TemplateConfig.pluginUniqueId).then(function (config) {
-                    config.Options = document.querySelector('#Options').value;
-                    config.AnInteger = document.querySelector('#AnInteger').value;
-                    config.TrueFalseSetting = document.querySelector('#TrueFalseSetting').checked;
-                    config.AString = document.querySelector('#AString').value;
-                    ApiClient.updatePluginConfiguration(TemplateConfig.pluginUniqueId, config).then(function (result) {
-                        Dashboard.processPluginConfigurationUpdateResult(result);
-                    });
-                });
-
-                e.preventDefault();
-                return false;
-            });
-        </script>
-    </div>
-</body>
-</html>

Jellyfin.Plugin.Template/Jellyfin.Plugin.Template.csproj

@@ -1,29 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-  <PropertyGroup>
-    <TargetFramework>net6.0</TargetFramework>
-    <RootNamespace>Jellyfin.Plugin.Template</RootNamespace>
-    <GenerateDocumentationFile>true</GenerateDocumentationFile>
-    <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
-    <Nullable>enable</Nullable>
-    <AnalysisMode>AllEnabledByDefault</AnalysisMode>
-    <CodeAnalysisRuleSet>../jellyfin.ruleset</CodeAnalysisRuleSet>
-  </PropertyGroup>
-
-  <ItemGroup>
-    <PackageReference Include="Jellyfin.Controller" Version="10.8.13" />
-    <PackageReference Include="Jellyfin.Model" Version="10.8.13" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <PackageReference Include="SerilogAnalyzer" Version="0.15.0" PrivateAssets="All" />
-    <PackageReference Include="StyleCop.Analyzers" Version="1.2.0-beta.507" PrivateAssets="All" />
-    <PackageReference Include="SmartAnalyzers.MultithreadingAnalyzer" Version="1.1.31" PrivateAssets="All" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <None Remove="Configuration\configPage.html" />
-    <EmbeddedResource Include="Configuration\configPage.html" />
-  </ItemGroup>
-
-</Project>

NuGet.config

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="utf-8"?>
+<configuration>
+  <packageSources>
+    <clear />
+    <add key="nuget.org" value="https://api.nuget.org/v3/index.json" protocolVersion="3" />
+  </packageSources>
+</configuration>

README.md

@@ -1,373 +1,306 @@
-# So you want to make a Jellyfin plugin
+# Jellyfin SRF Play Plugin
 
-Awesome! This guide is for you. Jellyfin plugins are written using the dotnet standard framework. What that means is you can write them in any language that implements the CLI or the DLI and can compile to net6.0. The examples on this page are in C# because that is what most of Jellyfin is written in, but F#, Visual Basic, and IronPython should all be compatible once compiled.
+A Jellyfin plugin for accessing SRF Play (Swiss Radio and Television) video-on-demand content and live sports streaming.
 
-## 0. Things you need to get started
+## Status
 
-- [Dotnet SDK 6.0](https://dotnet.microsoft.com/download)
+**Beta/Alpha** - This plugin has been tested on two Jellyfin instances and is working. Some clients may experience issues with hardware decoding, which appears to be client-specific behavior.
 
-- An editor of your choice. Some free choices are:
+## Quick Install
 
-   [Visual Studio Code](https://code.visualstudio.com)
+Add this repository URL in Jellyfin (Dashboard → Plugins → Repositories):
-
-   [Visual Studio Community Edition](https://visualstudio.microsoft.com/downloads)
-
-   [Mono Develop](https://www.monodevelop.com)
-
-## 0.5. Quickstarts
-
-We have a number of quickstart options available to speed you along the way.
-
-- [Download the Example Plugin Project](https://github.com/jellyfin/jellyfin-plugin-template/tree/master/Jellyfin.Plugin.Template) from this repository, open it in your IDE and go to [step 3](https://github.com/jellyfin/jellyfin-plugin-template#3-customize-plugin-information)
-
-- Install our dotnet template by [downloading the dotnet-template/content folder from this repo](https://github.com/jellyfin/jellyfin-plugin-template/tree/master/dotnet-template/content) or off of Nuget (Coming soon)
-
-   ```
-   dotnet new -i /path/to/templatefolder
-   ```
-
-- Run this command then skip to step 4
-
-   ```
-      dotnet new Jellyfin-plugin -name MyPlugin
-   ```
-
-If you'd rather start from scratch keep going on to step one. This assumes no specific editor or IDE and requires only the command line with dotnet in the path.
-
-## 1. Initialize Your Project
-
-Make a new dotnet standard project with the following command, it will make a directory for itself.
 
 ```
-dotnet new classlib -f net6.0 -n MyJellyfinPlugin
+https://gitea.tourolle.paris/dtourolle/jellyfin-srfPlay/raw/branch/master/manifest.json
 ```
 
-Now add the Jellyfin shared libraries.
+Then install "SRF Play" from the plugin catalog.
 
-```
+## Features
-dotnet add package Jellyfin.Model
+
-dotnet add package Jellyfin.Controller
+- Access to SRF Play VOD content (video-on-demand, no DRM-protected content)
+- **Live Sports Streaming** - Watch scheduled sports events (skiing, Formula 1, football, tennis, etc.)
+- Support for all Swiss broadcasting units (SRF, RTS, RSI, RTR, SWI)
+- Automatic content expiration handling
+- Continue Watching cleanup — ended livestreams and abandoned playback don't pile up in the resume row
+- Latest and trending content discovery
+- Quality selection (Auto lets CDN decide, SD prefers 480p/360p, HD prefers 1080p/720p)
+- HLS streaming support with Akamai token authentication
+- Proxy support for routing traffic through alternate gateways
+- Smart caching with reduced TTL for upcoming livestreams
+
+## Screenshots
+
+### Channel Menu
+![SRF Play Menu](res/menu.png)
+
+The main channel interface showing the content folders.
+### Playback
+![SRF Play Playback](res/playback.png)
+
+Video playback with HLS streaming support and quality selection.
+
+## Testing
+
+The plugin includes comprehensive testing:
+
+- **Unit tests** (xUnit framework) for core services
+- **API spec validation tests** for all business units (SRF, RTS, RSI, RTR, SWI)
+- **Integration testing** - Tested on multiple Jellyfin instances with VOD and live sports streaming
+
+**Run tests:**
+```bash
+# All tests
+dotnet test
+
+# Unit tests only
+dotnet test --filter "Category!=Integration&Category!=APISpec"
+
+# API spec tests only
+dotnet test --filter "Category=APISpec"
+
+# With coverage
+dotnet test --collect:"XPlat Code Coverage"
 ```
 
-You have an autogenerated Class1.cs file. You won't be needing this, so go ahead and delete it.
+See [Test Documentation](Jellyfin.Plugin.SRFPlay.Tests/README.md) for more details.
 
-## 2. Set Up the Basics
+## API Information
 
-There are a few mandatory classes you'll need for a plugin so we need to make them.
+**Base URL:** `https://il.srgssr.ch/integrationlayer/2.0/`
 
-### PluginConfiguration
+### Key Endpoints
 
-You can call it whatever you'd like really. This class is used to hold settings your plugin might need. We can leave it empty for now. This class should inherit from `MediaBrowser.Model.Plugins.BasePluginConfiguration`
+**Integration Layer API v2.0:**
+- `GET /mediaComposition/byUrn/{urn}` - Get video metadata and playable URLs
+- `GET /video/{businessUnit}/latest` - Get latest videos
+- `GET /video/{businessUnit}/trending` - Get trending videos
 
-### Plugin
+**Play v3 API:**
+- `GET /play/v3/api/{bu}/production/livestreams?eventType=SPORT` - Get scheduled sports livestreams
+- `GET /play/v3/api/{bu}/production/shows/{id}` - Get show details
+- `GET /play/v3/api/{bu}/production/videos-by-show-id?showId={id}` - Get episodes for a show
 
-This is the main class for your plugin. It will define your name, version and Id. It should inherit from `MediaBrowser.Common.Plugins.BasePlugin<PluginConfiguration>`
+**Akamai Token Service:**
+- `GET /akahd/token?acl=/{path}/*` - Authenticate stream URLs for playback
 
-Note: If you called your PluginConfiguration class something different, you need to put that between the <>
+### URN Format
 
-### Implement Required Properties
+- `urn:{bu}:video:{id}` - Video URN (VOD content)
+- `urn:{bu}:scheduled_livestream:video:{id}` - Scheduled sports livestream URN (supported)
+- `urn:{bu}:video:livestream_{channel}` - Live TV channel URN (not supported due to Widevine DRM)
 
-The Plugin class needs a few properties implemented before it can work correctly.
+Examples:
+- `urn:srf:video:c4927fcf-4ab4-4bcf-be4e-00e4ee9e6d6b` (VOD)
+- `urn:srf:scheduled_livestream:video:7b31c9a6-a96e-4c0e-bfc2-f0d6237f2233` (Sports event)
+- `urn:srf:video:c4927fcf-e1a0-0001-7edd-1ef01d441651` (SRF 1 Live - DRM protected)
 
-It needs an override on ID, an override on Name, and a constructor that follows a specific model. To get started you can use the following section.
+## Building the Plugin
 
-```c#
+### Prerequisites
-public Plugin(IApplicationPaths applicationPaths, IXmlSerializer xmlSerializer) : base(applicationPaths, xmlSerializer){}
+
-public override string Name => throw new System.NotImplementedException();
+- .NET 8.0 SDK
-public override Guid Id => Guid.Parse("");
+- Jellyfin 10.9.11 or later
+
+### Build Steps
+
+```bash
+cd Jellyfin.Plugin.SRFPlay
+dotnet build
 ```
 
-## 3. Customize Plugin Information
+### Output
 
-You need to populate some of your plugin's information. Go ahead a put in a string of the Name you've overridden name, and generate a GUID
+The compiled plugin will be in `bin/Debug/net8.0/`
 
-- **Windows Users**: you can use the Powershell command `New-Guid`, `[guid]::NewGuid()` or the Visual Studio GUID generator
+## Manual Installation
 
-- **Linux and OS X Users**: you can use the Powershell Core command `New-Guid` or this command from your shell of choice:
+1. Build the plugin (see above)
+2. Copy the compiled DLL to your Jellyfin plugins directory
+3. Restart Jellyfin
+4. Configure the plugin in Jellyfin Dashboard → Plugins → SRF Play
+5. The SRF Play channel will appear in Jellyfin with three main folders:
+   - **Latest Videos** - Recently published content
+   - **Trending Videos** - Popular content
+   - **Live Sports & Events** - Scheduled sports livestreams (skiing, F1, football, etc.)
 
-   ```bash
+## Configuration
-   od -x /dev/urandom | head -1 | awk '{OFS="-"; srand($6); sub(/./,"4",$5); sub(/./,substr("89ab",rand()*4,1),$6); print $2$3,$4,$5,$6,$7$8$9}'
-   ```
 
-or
+- **Business Unit**: Select the Swiss broadcasting unit (default: SRF)
+- **Quality Preference**: Choose video quality — Auto (first available, CDN decides), SD, or HD
+- **Content Refresh Interval**: How often to check for new content (1-168 hours)
+- **Expiration Check Interval**: How often to check for expired content (1-168 hours)
+- **Cache Duration**: How long to cache metadata (5-1440 minutes)
+- **Enable Latest Content**: Automatically discover latest videos
+- **Enable Trending Content**: Automatically discover trending videos
+- **Proxy Settings**: Configure proxy server for routing SRF API traffic (optional)
+  - **Use Proxy**: Enable/disable proxy usage
+  - **Proxy Address**: Proxy server URL (e.g., http://proxy.example.com:8080)
+  - **Proxy Username**: Optional authentication username
+  - **Proxy Password**: Optional authentication password
+- **Continue Watching Cleanup**: Stops stale SRF Play entries accumulating in the resume row
+  - **Clean up stale resume points**: Enables the daily "Clean Up SRF Play Continue Watching" task (4 AM)
+  - **Never keep a resume point for livestreams**: Clears the position the moment a livestream stops
+  - **Maximum Resume Point Age**: Clear entries untouched for this many days (default 30, 0 disables)
+  - **Minimum Resume Position**: Clear entries at or below this position (default 60s, 0 disables)
+  - **Finished Threshold**: Clear entries at or beyond this share of the runtime (default 92%, 0 disables)
 
-   ```bash
+Clearing a resume point only resets the playback position. Nothing is deleted, the item stays
-   uuidgen
+unwatched, and only SRF Play items are ever touched. The plugin config page also has
-   ```
+**Clean Up Stale Entries Now** and **Clear All SRF Play Entries** buttons for running it on demand.
 
-- Place that guid inside the `Guid.Parse("")` quotes to define your plugin's ID.
+For detailed proxy setup instructions, see [PROXY_SETUP_GUIDE.md](PROXY_SETUP_GUIDE.md).
 
-## 4. Adding Functionality
+## Troubleshooting
 
-Congratulations, you now have everything you need for a perfectly functional functionless Jellyfin plugin! You can try it out right now if you'd like by compiling it, then placing the dll you generate in the plugins folder under your Jellyfin config directory. If you want to try and hook it up to a debugger make sure you copy the generated PDB file alongside it.
+If you encounter issues with the plugin:
+- Check [DEBUG_GUIDE.md](DEBUG_GUIDE.md) for detailed logging information
+- Enable debug logging in Jellyfin to see detailed request/response information
+- Common issues include DRM-protected content and geo-restrictions
 
-Most people aren't satisfied with just having an entry in a menu for their plugin, most people want to have some functionality, so lets look at how to add it.
+## Technical Architecture
 
-### 4a. Implement Interfaces
+### Directory Structure
 
-If the functionality you are trying to add is functionality related to something that Jellyfin has an interface for you're in luck. Jellyfin uses some automatic discovery and injection to allow any interfaces you implement in your plugin to be available in Jellyfin.
+```
-
+Jellyfin.Plugin.SRFPlay/
-Here's some interfaces you could implement for common use cases:
+├── Api/
-
+│   ├── Models/                    # API response models
-- **IAuthenticationProvider** - Allows you to add an authentication provider that can authenticate a user based on a name and a password, but that doesn't expect to deal with local users.
+│   │   ├── MediaComposition.cs    #   Root composition (HasChapters helper)
-- **IBaseItemComparer** - Allows you to add sorting rules for dealing with media that will show up in sort menus
+│   │   ├── Chapter.cs             #   Video/episode chapter with resources
-- **IIntroProvider** - Allows you to play a piece of media before another piece of media (i.e. a trailer before a movie, or a network bumper before an episode of a show)
+│   │   ├── Resource.cs            #   Stream URL entry (IsPlayable helper)
-- **IItemResolver** - Allows you to define custom media types
+│   │   ├── Show.cs
-- **ILibraryPostScanTask** - Allows you to define a task that fires after scanning a library
+│   │   ├── Episode.cs
-- **IMetadataSaver** - Allows you to define a metadata standard that Jellyfin can use to write metadata
+│   │   └── PlayV3/                # Play v3 API models
-- **IResolverIgnoreRule** - Allows you to define subpaths that are ignored by media resolvers for use with another function (i.e. you wanted to have a theme song for each tv series stored in a subfolder that could be accessed by your plugin for playback in a menu).
+│   │       ├── PlayV3Show.cs
-- **IScheduledTask** - Allows you to create a scheduled task that will appear in the scheduled task lists on the dashboard.
+│   │       ├── PlayV3Topic.cs
-
+│   │       ├── PlayV3Video.cs
-There are loads of other interfaces that can be used, but you'll need to poke around the API to get some info. If you're an expert on a particular interface, you should help [contribute some documentation](https://docs.jellyfin.org/general/contributing/index.html)!
+│   │       ├── PlayV3TvProgram.cs
-
+│   │       ├── PlayV3Response.cs
-### 4b. Use plugin aimed interfaces to add custom functionality
+│   │       ├── PlayV3DirectResponse.cs
-
+│   │       └── PlayV3DataContainer.cs
-If your plugin doesn't fit perfectly neatly into a predefined interface, never fear, there are a set of interfaces and classes that allow your plugin to extend Jellyfin any which way you please. Here's a quick overview on how to use them
+│   ├── SRFApiClient.cs            # HTTP client for SRF APIs
-
+│   ├── ISRFApiClientFactory.cs    # Factory interface
-- **IPluginConfigurationPage** - Allows you to have a plugin config page on the dashboard. If you used one of the quickstart example projects, a premade page with some useful components to work with has been created for you! If not you can check out this guide here for how to whip one up.
+│   └── SRFApiClientFactory.cs     # Factory implementation
-
+├── Channels/
-- **IServerEntryPoint** - Allows you to run code at server startup that will stay in memory. You can make as many of these as you need and it is wildly useful for loading configs or persisting state. **Be aware that your main plugin class (IBasePlugin) cannot also be a IServerEntryPoint.**
+│   └── SRFPlayChannel.cs          # Channel implementation
-
+├── Configuration/
-- **ControllerBase** - Allows you to define custom REST-API endpoints. This is the default ASP.NET Web-API controller. You can use it exactly as you would in a normal Web-API project. Learn more about it [here](https://docs.microsoft.com/aspnet/core/web-api/?view=aspnetcore-5.0).
+│   ├── PluginConfiguration.cs
-
+│   └── configPage.html
-Likewise you might need to get data and services from the Jellyfin core, Jellyfin provides a number of interfaces you can add as parameters to your plugin constructor which are then made available in your project (you can see the 2 mandatory ones that are needed by the plugin system in the constructor as is).
+├── Constants/
-
+│   └── ApiEndpoints.cs            # API base URLs and endpoint constants
-- **IBlurayExaminer** - Allows you to examine blu-ray folders
+├── Controllers/
-- **IDtoService** - Allows you to create data transport objects, presumably to send to other plugins or to the core
+│   └── StreamProxyController.cs   # HLS proxy endpoints (master/variant/segment)
-- **ILibraryManager** - Allows you to directly access the media libraries without hopping through the API
+├── Services/
-- **ILocalizationManager** - Allows you tap into the main localization engine which governs translations, rating systems, units etc...
+│   ├── Interfaces/                # Service contracts
-- **INetworkManager** - Allows you to get information about the server's networking status
+│   │   ├── IStreamProxyService.cs
-- **IServerApplicationPaths** - Allows you to get the running server's paths
+│   │   ├── IStreamUrlResolver.cs
-- **IServerConfigurationManager** - Allows you to write or read server configuration data into the application paths
+│   │   ├── IMediaCompositionFetcher.cs
-- **ITaskManager** - Allows you to execute and manipulate scheduled tasks
+│   │   ├── IMediaSourceFactory.cs
-- **IUserManager** - Allows you to retrieve user info and user library related info
+│   │   ├── IMetadataCache.cs
-- **IXmlSerializer** - Allows you to use the main xml serializer
+│   │   ├── IContentRefreshService.cs
-- **IZipClient** - Allows you to use the core zip client for compressing and decompressing data
+│   │   ├── IContentExpirationService.cs
-
+│   │   └── ICategoryService.cs
-## 5. Create a Repository
+│   ├── StreamProxyService.cs      # HLS proxy: auth, manifest rewriting, segments
-
+│   ├── StreamUrlResolver.cs       # Stream selection & Akamai authentication
-- [See blog post](https://jellyfin.org/posts/plugin-updates/)
+│   ├── MediaCompositionFetcher.cs # Cached API fetcher
-
+│   ├── MediaSourceFactory.cs      # Jellyfin MediaSourceInfo builder
-## 6. Set Up Debugging
+│   ├── MetadataCache.cs           # Thread-safe ConcurrentDictionary cache
-
+│   ├── ContentExpirationService.cs
-Debugging can be set up by creating tasks which will be executed when running the plugin project. The specifics on setting up these tasks are not included as they may differ from IDE to IDE. The following list describes the general process:
+│   ├── ContentRefreshService.cs
-
+│   └── CategoryService.cs
-- Compile the plugin in debug mode.
+├── Providers/
-- Create the plugin directory if it doesn't exist.
+│   ├── SRFSeriesProvider.cs       # Series metadata
-- Copy the plugin into your server's plugin directory. The server will then execute it.
+│   ├── SRFEpisodeProvider.cs      # Episode metadata
-- Make sure to set the working directory of the program being debugged to the working directory of the Jellyfin Server.
+│   ├── SRFImageProvider.cs        # Image fetching
-- Start the server.
+│   └── SRFMediaProvider.cs        # Playback URLs
-
+├── Utilities/
-Some IDEs like Visual Studio Code may need the following compile flags to compile the plugin:
+│   ├── Extensions.cs              # BusinessUnit.ToLowerString() extension
-
+│   ├── MimeTypeHelper.cs          # Content-type detection
-```shell
+│   ├── PlaceholderImageGenerator.cs
-dotnet build Your-Plugin.sln /property:GenerateFullPaths=true /consoleloggerparameters:NoSummary
+│   └── UrnHelper.cs               # URN parsing utilities
+├── ScheduledTasks/
+│   ├── ContentRefreshTask.cs      # Periodic content refresh
+│   └── ExpirationCheckTask.cs     # Periodic expiration check
+├── ServiceRegistrator.cs          # DI registration
+└── Plugin.cs                      # Main plugin entry point
 ```
 
-These flags generate the full paths for file names and **do not** generate a summary during the build process as this may lead to duplicate errors in the problem panel of your IDE.
+### Key Components
 
-### 6.a Set Up Debugging on Visual Studio
+1. **API Client** (`SRFApiClient`): HTTP requests to SRF Integration Layer and Play v3 API, with proxy support
+2. **Channel** (`SRFPlayChannel`): SRF Play channel with Latest, Trending, and Live Sports folders
+3. **Stream Proxy** (`StreamProxyService` + `StreamProxyController`): HLS proxy that handles Akamai token auth, manifest URL rewriting, deferred authentication, and token refresh for both VOD and livestreams
+4. **Stream Resolver** (`StreamUrlResolver`): Selects optimal HLS stream by quality preference, filters DRM content
+5. **Metadata Cache** (`MetadataCache`): Thread-safe `ConcurrentDictionary` cache with dynamic TTL for livestreams
+6. **Media Composition Fetcher** (`MediaCompositionFetcher`): Cached wrapper around API client for media composition requests
+7. **Content Providers** (`SRFSeriesProvider`, `SRFEpisodeProvider`, `SRFImageProvider`, `SRFMediaProvider`): Jellyfin integration for series, episodes, images, and media sources
+8. **Scheduled Tasks**: Automatic content refresh and expiration management
+9. **Utilities**: Business unit extensions, MIME type helpers, URN parsing, placeholder image generation
 
-Visual Studio allows developers to connect to other processes and debug them, setting breakpoints and inspecting the variables of the program. We can set this up following this steps:
+## Important Notes
-On this section we will explain how to set up our solution to enable debugging before the server starts.
 
-1. Right-click on the solution, And click on Add -> Existing Project...
+### Content Limitations
-2. Locate Jellyfin executable in your installation folder and click on 'Open'. It is called `Jellyfin.exe`. Now The solution will have a new "Project" called Jellyfin. This is the executable, not the source code of Jellyfin.
-3. Right-click on this new project and click on 'Set up as Startup Project'
-4. Right-click on this new project and click on 'Properties'
-5. Make sure that the 'Attach' parameter is set to 'No'
 
-From now on, everytime you click on start from Visual Studio, it will start Jellyfin attached to the debugger!
+- **No DRM content**: Only non-DRM protected content is accessible (no Widevine/FairPlay)
+- **No live TV channels**: Main channels (SRF 1, SRF zwei, SRF info) use DRM and are not supported
+- **Sports livestreams supported**: Scheduled sports events (skiing, F1, football, etc.) work without DRM
+- **Content expiration**: SRF content has validity periods, plugin tracks and removes expired content
+- **Upcoming events**: Sports events appear before they start but require channel refresh to play once live
+- **No subtitles**: Subtitle support not currently implemented
 
-The only thing left to do is to compile the project as it is specified a few lines above and you are done.
+### Extensibility
 
-### 6.b Automate the Setup on Visual Studio Code
+The plugin is designed to support all Swiss broadcasting units:
+- **SRF** (Schweizer Radio und Fernsehen - German)
+- **RTS** (Radio Télévision Suisse - French)  
+- **RSI** (Radiotelevisione svizzera - Italian)
+- **RTR** (Radiotelevisiun Svizra Rumantscha - Romansh)
+- **SWI** (Swiss World International)
 
-Visual Studio Code allows developers to automate the process of starting all necessary dependencies to start debugging the plugin. This guide assumes the reader is familiar with the [documentation on debugging in Visual Studio Code](https://code.visualstudio.com/docs/editor/debugging) and has read the documentation in this file. It is assumed that the Jellyfin Server has already been compiled once. However, should one desire to automatically compile the server before the start of the debugging session, this can be easily implemented, but is not further discussed here.
+Currently focused on SRF but easily extensible.
 
-A full example, which aims to be portable may be found in this repo's `.vscode` folder.
+## Development
 
-This example expects you to clone `jellyfin`, `jellyfin-web` and `jellyfin-plugin-template` under the same parent directory, though you can customize this in `settings.json`
+The plugin includes:
+- Complete API integration with SRF Play (Integration Layer v2.0 and Play v3)
+- **Live sports streaming** with scheduled event detection
+- Channel with Latest, Trending, and Live Sports folders
+- Metadata providers for series and episodes
+- Image fetching and caching
+- HLS stream playback with Akamai token authentication
+- Automatic content expiration handling
+- Scheduled tasks for content refresh
+- Smart caching with dynamic TTL for upcoming livestreams
 
-1. Create a `settings.json` file inside your `.vscode` folder, to specify common options specific to your local setup.
+### Known Issues
-   ```jsonc
-    {
-        // jellyfinDir : The directory of the cloned jellyfin server project
-        // This needs to be built once before it can be used
-        "jellyfinDir"     : "${workspaceFolder}/../jellyfin/Jellyfin.Server",
-        // jellyfinWebDir : The directory of the cloned jellyfin-web project
-        // This needs to be built once before it can be used
-        "jellyfinWebDir"  : "${workspaceFolder}/../jellyfin-web",
-        // jellyfinDataDir : the root data directory for a running jellyfin instance
-        // This is where jellyfin stores its configs, plugins, metadata etc
-        // This is platform specific by default, but on Windows defaults to
-        // ${env:LOCALAPPDATA}/jellyfin
-        "jellyfinDataDir" : "${env:LOCALAPPDATA}/jellyfin",
-        // The name of the plugin
-        "pluginName" : "Jellyfin.Plugin.Template",
-    }
-   ```
 
-1. To automate the launch process, create a new `launch.json` file for C# projects inside the `.vscode` folder. The example below shows only the relevant parts of the file. Adjustments to your specific setup and operating system may be required.
+- Some clients may experience issues with hardware decoding (appears to be client-specific)
+- Some edge cases may need additional handling
+- Performance optimization may be needed for very large content catalogs
 
-   ```jsonc
+### Contributing
-    {
-        // Paths and plugin names are configured in settings.json
-        "version": "0.2.0",
-        "configurations": [
-            {
-                "type": "coreclr",
-                "name": "Launch",
-                "request": "launch",
-                "preLaunchTask": "build-and-copy",
-                "program": "${config:jellyfinDir}/bin/Debug/net6.0/jellyfin.dll",
-                "args": [
-                //"--nowebclient"
-                "--webdir",
-                "${config:jellyfinWebDir}/dist/"
-                ],
-                "cwd": "${config:jellyfinDir}",
-            }
-        ]
-    }
 
-   ```
+Contributions welcome! This project is hosted on a self-hosted [Gitea](https://gitea.tourolle.paris/dtourolle/jellyfin-srfPlay) instance.
 
-   The `request` type is specified as `launch`, as this `launch.json` file will start the Jellyfin Server process. The `preLaunchTask` defines a task that will run before the Jellyfin Server starts. More on this later. It is important to set the `program` path to the Jellyin Server program and set the current working directory (`cwd`) to the working directory of the Jellyfin Server.
+**You don't need a separate account** — you can sign in with your existing GitHub account. On the [sign-in page](https://gitea.tourolle.paris/user/login), choose **"Sign in with GitHub"** to register and log in via GitHub OAuth. Once signed in, you can:
-   The `args` option allows to specify arguments to be passed to the server, e.g. whether Jellyfin should start with the web-client or without it.
 
-2. Create a `tasks.json` file inside your `.vscode` folder and specify a `build-and-copy` task that will run in `sequence` order. This tasks depends on multiple other tasks and all of those other tasks can be defined as simple `shell` tasks that run commands like the `cp` command to copy a file. The sequence to run those tasks in is given below. Please note that it might be necessary to adjust the examples for your specific setup and operating system.
+- **Raise issues** — report bugs or request features on the [issue tracker](https://gitea.tourolle.paris/dtourolle/jellyfin-srfPlay/issues)
+- **Contribute code** — fork the repository, push a branch, and open a pull request
 
-   The full file is shown here - Specific sections will be discussed in depth
+## License
-    ```jsonc
-    {
-        // Paths and plugin name are configured in settings.json
-        "version": "2.0.0",
-        "tasks": [
-            {
-            // A chain task - build the plugin, then copy it to your
-            // jellyfin server's plugin directory
-            "label": "build-and-copy",
-            "dependsOrder": "sequence",
-            "dependsOn": ["build", "make-plugin-dir", "copy-dll"]
-            },
-            {
-            // Build the plugin
-            "label": "build",
-            "command": "dotnet",
-            "type": "shell",
-            "args": [
-                "publish",
-                "${workspaceFolder}/${config:pluginName}.sln",
-                "/property:GenerateFullPaths=true",
-                "/consoleloggerparameters:NoSummary"
-            ],
-            "group": "build",
-            "presentation": {
-                "reveal": "silent"
-            },
-            "problemMatcher": "$msCompile"
-            },
-            {
-                // Ensure the plugin directory exists before trying to use it
-                "label": "make-plugin-dir",
-                "type": "shell",
-                "command": "mkdir",
-                "args": [
-                "-Force",
-                "-Path",
-                "${config:jellyfinDataDir}/plugins/${config:pluginName}/"
-                ]
-            },
-            {
-                // Copy the plugin dll to the jellyfin plugin install path
-                // This command copies every .dll from the build directory to the plugin dir
-                // Usually, you probablly only need ${config:pluginName}.dll
-                // But some plugins may bundle extra requirements
-                "label": "copy-dll",
-                "type": "shell",
-                "command": "cp",
-                "args": [
-                "./${config:pluginName}/bin/Debug/net6.0/publish/*",
-                "${config:jellyfinDataDir}/plugins/${config:pluginName}/"
-                ]
 
-            },
+See LICENSE file for details.
-        ]
-    }
 
-    ```
+## Acknowledgments
-    1.  The "build-and-copy" task which triggers all of the other tasks
-    ```jsonc
-        {
-        // A chain task - build the plugin, then copy it to your
-        // jellyfin server's plugin directory
-        "label": "build-and-copy",
-        "dependsOrder": "sequence",
-        "dependsOn": ["build", "make-plugin-dir", "copy-dll"]
-        },
-    ```
-    2.  A build task. This task builds the plugin without generating summary, but with full paths for file names enabled.
 
-        ```jsonc
+This plugin was developed partly using [Claude Code](https://docs.anthropic.com/en/docs/claude-code) by Anthropic.
-            {
-            // Build the plugin
-            "label": "build",
-            "command": "dotnet",
-            "type": "shell",
-            "args": [
-                "publish",
-                "${workspaceFolder}/${config:pluginName}.sln",
-                "/property:GenerateFullPaths=true",
-                "/consoleloggerparameters:NoSummary"
-            ],
-            "group": "build",
-            "presentation": {
-                "reveal": "silent"
-            },
-            "problemMatcher": "$msCompile"
-            },
-        ```
 
-    3.  A tasks which creates the necessary plugin directory and a sub-folder for the specific plugin. The plugin directory is located below the [data directory](https://jellyfin.org/docs/general/administration/configuration.html) of the Jellyfin Server. As an example, the following path can be used for the bookshelf plugin: `$HOME/.local/share/jellyfin/plugins/Bookshelf/`
+Inspired by the excellent [Kodi SRG SSR addon](https://github.com/goggle/script.module.srgssr) by [@goggle](https://github.com/goggle), which served as a fantastic reference for understanding the SRG SSR API structure, authentication mechanisms, and handling of scheduled livestreams.
-        ```jsonc
-            {
-                // Ensure the plugin directory exists before trying to use it
-                "label": "make-plugin-dir",
-                "type": "shell",
-                "command": "mkdir",
-                "args": [
-                "-Force",
-                "-Path",
-                "${config:jellyfinDataDir}/plugins/${config:pluginName}/"
-                ]
-            },
-        ```
 
-    4.  A tasks which copies the plugin dll which has been built in step 2.1. The file is copied into it's specific plugin directory within the server's plugin directory.
+## References
 
-        ```jsonc
+- [SRF Play](https://www.srf.ch/play)
-            {
+- [Jellyfin Plugin Documentation](https://jellyfin.org/docs/general/server/plugins/)
-                // Copy the plugin dll to the jellyfin plugin install path
+- [SRG SSR Integration Layer API](https://il.srgssr.ch/)
-                // This command copies every .dll from the build directory to the plugin dir
+- [Kodi SRG SSR Addon](https://github.com/goggle/script.module.srgssr) - Reference implementation
-                // Usually, you probablly only need ${config:pluginName}.dll
-                // But some plugins may bundle extra requirements
-                "label": "copy-dll",
-                "type": "shell",
-                "command": "cp",
-                "args": [
-                "./${config:pluginName}/bin/Debug/net6.0/publish/*",
-                "${config:jellyfinDataDir}/plugins/${config:pluginName}/"
-                ]
-            },
-        ```
-
-## Licensing
-
-Licensing is a complex topic. This repository features a GPLv3 license template that can be used to provide a good default license for your plugin. You may alter this if you like, but if you do a permissive license must be chosen.
-
-Due to how plugins in Jellyfin work, when your plugin is compiled into a binary, it will link against the various Jellyfin binary NuGet packages. These packages are licensed under the GPLv3. Thus, due to the nature and restrictions of the GPL, the binary plugin you get will also be licensed under the GPLv3.
-
-If you accept the default GPLv3 license from this template, all will be good. However if you choose a different license, please keep this fact in mind, as it might not always be obvious that an, e.g. MIT-licensed plugin would become GPLv3 when compiled.
-
-Please note that this also means making "proprietary", source-unavailable, or otherwise "hidden" plugins for public consumption is not permitted. To build a Jellyfin plugin for distribution to others, it must be under the GPLv3 or a permissive open-source license that can be linked against the GPLv3.

USAGE_GUIDE.md

@@ -0,0 +1,92 @@
+# SRF Play Plugin - Usage Guide
+
+## Finding the Channel in Jellyfin
+
+After installing and enabling the plugin, you can access SRF Play content through the **Channels** feature in Jellyfin.
+
+### Step-by-Step Instructions:
+
+1. **Open Jellyfin** in your web browser
+
+2. **Navigate to Channels**:
+   - On the Jellyfin home screen, look in the left sidebar menu
+   - Click on **"Live TV & Channels"** or **"Channels"**
+   - You should see "SRF Play" listed among your available channels
+
+3. **Browse Content**:
+   - Click on the "SRF Play" channel
+   - You'll see two main folders:
+     - **Latest Videos** - Recently published SRF content
+     - **Trending Videos** - Popular content from SRF
+
+4. **Watch Videos**:
+   - Click into either folder to browse videos
+   - Click on any video to play it
+   - Videos will stream directly via HLS
+
+### Alternative Navigation:
+
+If you don't see a "Channels" section in the sidebar:
+
+1. Go to **Dashboard** (gear icon or Admin menu)
+2. Click on **"Live TV"** in the left menu
+3. Look for **"Channels"** section
+4. Enable the "SRF Play" channel if it's not already enabled
+
+### Configuration:
+
+To configure the plugin (change business unit, quality, etc.):
+
+1. Go to **Dashboard** → **Plugins**
+2. Find **"SRF Play"** in the list
+3. Click on it to access settings
+4. Configure:
+   - **Business Unit**: SRF, RTS, RSI, RTR, or SWI
+   - **Quality Preference**: Auto, SD, or HD
+   - **Enable Latest Content**: Show latest videos
+   - **Enable Trending Content**: Show trending videos
+
+### Troubleshooting:
+
+**Channel not appearing?**
+- Restart Jellyfin after installing the plugin
+- Check Dashboard → Plugins to ensure SRF Play is enabled
+- Check the plugin configuration (Dashboard → Plugins → SRF Play)
+
+**No videos showing?**
+- Ensure "Enable Latest Content" and/or "Enable Trending Content" are checked in plugin settings
+- Check Jellyfin logs for any error messages (Dashboard → Logs)
+- Verify your Jellyfin server has internet access to reach `il.srgssr.ch`
+
+**Videos won't play?**
+- Check your Jellyfin server can access HLS streams
+- Verify firewall settings allow outbound HTTPS connections
+- Check the quality setting - try "Auto" if HD/SD isn't working
+
+### What Content is Available?
+
+- **Latest Videos**: The most recently published content from the selected business unit (SRF, RTS, etc.)
+- **Trending Videos**: Popular/trending content from the business unit
+- All videos are VOD (Video on Demand) - no live TV channels due to DRM restrictions
+
+### Content Expiration:
+
+SRF content has expiration dates. The plugin:
+- Automatically filters out expired content
+- Runs scheduled tasks to remove expired items from your library
+- Checks expiration every 24 hours (configurable)
+
+### Notes:
+
+- Only non-DRM content is accessible (no Widevine protected streams)
+- Live TV channels are not available due to DRM
+- Content availability depends on the selected business unit and SRF's content policies
+- The plugin shows up to 50 videos per category
+
+## Need Help?
+
+If you encounter issues:
+1. Check Jellyfin logs (Dashboard → Logs)
+2. Verify plugin configuration
+3. Ensure your network allows access to `il.srgssr.ch`
+4. Report issues on the plugin's GitHub repository

build.yaml

@@ -1,16 +1,21 @@
 ---
-name: "Template"
+name: "SRFPlay"
-guid: "eb5d7894-8eef-4b36-aa6f-5d124e828ce1"
+guid: "a4b12f86-8c3d-4e9a-b7f2-1d5e6c8a9b4f"
 version: "1.0.0.0"
-targetAbi: "10.8.0.0"
+targetAbi: "10.9.0.0"
-framework: "net6.0"
+framework: "net8.0"
-overview: "Short description about your plugin"
+overview: "SRF Play plugin for Jellyfin"
 description: >
-  This is a longer description that can span more than one
+  Provides access to SRF Play content in Jellyfin, including
-  line and include details about your plugin.
+  live streams and on-demand content from Swiss Radio and Television.
-category: "General"
+category: "LiveTV"
 owner: "jellyfin"
+imageUrl: "https://www.srf.ch/static/img/srf-logo.svg"
 artifacts:
-- "Jellyfin.Plugin.Template.dll"
+- "Jellyfin.Plugin.SRFPlay.dll"
+build_type: "dotnet"
+dotnet_configuration: "Release"
+dotnet_framework: "net8.0"
+project: "Jellyfin.Plugin.SRFPlay/Jellyfin.Plugin.SRFPlay.csproj"
 changelog: >
-  changelog
+  Initial release

manifest-nightly.json

@@ -0,0 +1,45 @@
+[
+  {
+    "guid": "a4b12f86-8c3d-4e9a-b7f2-1d5e6c8a9b4f",
+    "name": "SRF Play (Nightly)",
+    "description": "NIGHTLY/UNSTABLE builds of the SRF Play plugin for Jellyfin. Built automatically from the master branch on every push. Expect bugs. For stable releases use the regular SRF Play repository instead.",
+    "overview": "Nightly builds of SRF Play for Jellyfin",
+    "owner": "dtourolle",
+    "category": "Live TV",
+    "imageUrl": "https://gitea.tourolle.paris/dtourolle/jellyfin-srfPlay/raw/branch/master/assests/main%20logo.png",
+    "versions": [
+      {
+        "version": "1.0.20260908.201",
+        "changelog": "Nightly build 1.0.20260908.201 (d0d5d06)",
+        "targetAbi": "10.9.0.0",
+        "sourceUrl": "https://gitea.tourolle.paris/dtourolle/jellyfin-srfPlay/releases/download/latest/srfplay_1.0.20260908.201.zip",
+        "checksum": "e1c9ed45efbbe7c889f2158fe7c1c537",
+        "timestamp": "2026-09-08T17:28:03Z"
+      },
+      {
+        "version": "1.0.20260903.198",
+        "changelog": "Nightly build 1.0.20260903.198 (699b543)",
+        "targetAbi": "10.9.0.0",
+        "sourceUrl": "https://gitea.tourolle.paris/dtourolle/jellyfin-srfPlay/releases/download/latest/srfplay_1.0.20260903.198.zip",
+        "checksum": "fcd415e82c95a6fe1e34db1d187a684f",
+        "timestamp": "2026-09-03T19:09:41Z"
+      },
+      {
+        "version": "1.0.20260627.189",
+        "changelog": "Nightly build 1.0.20260627.189 (7c81ef9)",
+        "targetAbi": "10.9.0.0",
+        "sourceUrl": "https://gitea.tourolle.paris/dtourolle/jellyfin-srfPlay/releases/download/latest/srfplay_1.0.20260627.189.zip",
+        "checksum": "553ac3f806bce24e5aae3b2c8d17395b",
+        "timestamp": "2026-06-27T13:46:17Z"
+      },
+      {
+        "version": "1.0.20260627.185",
+        "changelog": "Nightly build 1.0.20260627.185 (1101385)",
+        "targetAbi": "10.9.0.0",
+        "sourceUrl": "https://gitea.tourolle.paris/dtourolle/jellyfin-srfPlay/releases/download/latest/srfplay_1.0.20260627.185.zip",
+        "checksum": "577af725ca202bec555bf51905b75913",
+        "timestamp": "2026-06-27T09:30:57Z"
+      }
+    ]
+  }
+]

manifest.json

@@ -0,0 +1,157 @@
+[
+  {
+    "guid": "a4b12f86-8c3d-4e9a-b7f2-1d5e6c8a9b4f",
+    "name": "SRF Play",
+    "description": "SRF Play plugin for Jellyfin enables streaming of content from SRF (Swiss Radio and Television). Access live TV channels and on-demand content from Switzerland's German-language public broadcaster directly within Jellyfin.",
+    "overview": "Stream SRF content in Jellyfin",
+    "owner": "dtourolle",
+    "category": "Live TV",
+    "imageUrl": "https://gitea.tourolle.paris/dtourolle/jellyfin-srfPlay/raw/branch/master/assests/main%20logo.png",
+    "versions": [
+      {
+        "version": "1.1.2",
+        "changelog": "Release 1.1.2",
+        "targetAbi": "10.9.0.0",
+        "sourceUrl": "https://gitea.tourolle.paris/dtourolle/jellyfin-srfPlay/releases/download/v1.1.2/srfplay_1.1.2.0.zip",
+        "checksum": "09b96308e9796bf25d681da29d10bfed",
+        "timestamp": "2026-09-08T17:31:00Z"
+      },
+      {
+        "version": "1.1.1",
+        "changelog": "Release 1.1.1",
+        "targetAbi": "10.9.0.0",
+        "sourceUrl": "https://gitea.tourolle.paris/dtourolle/jellyfin-srfPlay/releases/download/v1.1.1/srfplay_1.1.1.0.zip",
+        "checksum": "4354a495d2d24ab2313c96bb5ea837bb",
+        "timestamp": "2026-08-12T16:59:30Z"
+      },
+      {
+        "version": "1.1.0",
+        "changelog": "Release 1.1.0",
+        "targetAbi": "10.9.0.0",
+        "sourceUrl": "https://gitea.tourolle.paris/dtourolle/jellyfin-srfPlay/releases/download/v1.1.0/srfplay_1.1.0.0.zip",
+        "checksum": "2094b00b29f79e7625fcd3ebf046674f",
+        "timestamp": "2026-06-27T09:33:04Z"
+      },
+      {
+        "version": "0.0.0.0",
+        "changelog": "Latest Build",
+        "targetAbi": "10.9.0.0",
+        "sourceUrl": "https://gitea.tourolle.paris/dtourolle/jellyfin-srfPlay/releases/download/latest/srfplay_1.0.0.0.zip",
+        "checksum": "2ed3281990b56fbfb5f75a1ee82a2f55",
+        "timestamp": "2026-06-27T09:01:57Z"
+      },
+      {
+        "version": "1.0.32",
+        "changelog": "Release 1.0.32",
+        "targetAbi": "10.9.0.0",
+        "sourceUrl": "https://gitea.tourolle.paris/dtourolle/jellyfin-srfPlay/releases/download/v1.0.32/srfplay_1.0.32.0.zip",
+        "checksum": "82f53848f2e2b15a35ea731ee69ee402",
+        "timestamp": "2026-06-27T07:16:38Z"
+      },
+      {
+        "version": "1.0.31",
+        "changelog": "Release 1.0.31",
+        "targetAbi": "10.9.0.0",
+        "sourceUrl": "https://gitea.tourolle.paris/dtourolle/jellyfin-srfPlay/releases/download/v1.0.31/srfplay_1.0.31.0.zip",
+        "checksum": "4e499de15687e6e328ddca41c6192485",
+        "timestamp": "2026-06-27T06:54:01Z"
+      },
+      {
+        "version": "1.0.30",
+        "changelog": "Release 1.0.30",
+        "targetAbi": "10.9.0.0",
+        "sourceUrl": "https://gitea.tourolle.paris/dtourolle/jellyfin-srfPlay/releases/download/v1.0.30/srfplay_1.0.30.0.zip",
+        "checksum": "06731df9ba3d2dab53885c9c8ac95fa6",
+        "timestamp": "2026-05-03T16:44:57Z"
+      },
+      {
+        "version": "1.0.29",
+        "changelog": "Release 1.0.29",
+        "targetAbi": "10.9.0.0",
+        "sourceUrl": "https://gitea.tourolle.paris/dtourolle/jellyfin-srfPlay/releases/download/v1.0.29/srfplay_1.0.29.0.zip",
+        "checksum": "fb745388e64299497262d9ad370d8823",
+        "timestamp": "2026-05-03T16:07:24Z"
+      },
+      {
+        "version": "1.0.27",
+        "changelog": "Release 1.0.27",
+        "targetAbi": "10.9.0.0",
+        "sourceUrl": "https://gitea.tourolle.paris/dtourolle/jellyfin-srfPlay/releases/download/v1.0.27/srfplay_1.0.27.0.zip",
+        "checksum": "1e15e35452f7b82bf74d8c3560c15949",
+        "timestamp": "2026-03-07T16:40:17Z"
+      },
+      {
+        "version": "1.0.25",
+        "changelog": "Release 1.0.25",
+        "targetAbi": "10.9.0.0",
+        "sourceUrl": "https://gitea.tourolle.paris/dtourolle/jellyfin-srfPlay/releases/download/v1.0.25/srfplay_1.0.25.0.zip",
+        "checksum": "5e4599cfeee7e0845a1be30ec288cc0b",
+        "timestamp": "2026-03-07T15:11:52Z"
+      },
+      {
+        "version": "1.0.24",
+        "changelog": "Release 1.0.24",
+        "targetAbi": "10.9.0.0",
+        "sourceUrl": "https://gitea.tourolle.paris/dtourolle/jellyfin-srfPlay/releases/download/v1.0.24/srfplay_1.0.24.0.zip",
+        "checksum": "f54dfb8cd9b555471859ffc89c35fb90",
+        "timestamp": "2026-03-07T14:55:13Z"
+      },
+      {
+        "version": "1.0.23",
+        "changelog": "Release 1.0.23",
+        "targetAbi": "10.9.0.0",
+        "sourceUrl": "https://gitea.tourolle.paris/dtourolle/jellyfin-srfPlay/releases/download/v1.0.23/srfplay_1.0.23.0.zip",
+        "checksum": "cd98644c758c84e2759699ea1da5a716",
+        "timestamp": "2026-02-28T12:13:10Z"
+      },
+      {
+        "version": "1.0.22",
+        "changelog": "Release 1.0.22",
+        "targetAbi": "10.9.0.0",
+        "sourceUrl": "https://gitea.tourolle.paris/dtourolle/jellyfin-srfPlay/releases/download/v1.0.22/srfplay_1.0.22.0.zip",
+        "checksum": "08177ed8edb4b4cf2441bc808b9860bb",
+        "timestamp": "2026-02-28T11:36:30Z"
+      },
+      {
+        "version": "1.0.16",
+        "changelog": "Release 1.0.16",
+        "targetAbi": "10.9.0.0",
+        "sourceUrl": "https://gitea.tourolle.paris/dtourolle/jellyfin-srfPlay/releases/download/v1.0.16/srfplay_1.0.16.0.zip",
+        "checksum": "0b3a142dd6cea1f00855bcb11bcd847c",
+        "timestamp": "2026-01-17T20:31:09Z"
+      },
+      {
+        "version": "1.0.15",
+        "changelog": "Release 1.0.15",
+        "targetAbi": "10.9.0.0",
+        "sourceUrl": "https://gitea.tourolle.paris/dtourolle/jellyfin-srfPlay/releases/download/v1.0.15/srfplay_1.0.15.0.zip",
+        "checksum": "3140ef53a7460d7ce52daf48bbb37e4d",
+        "timestamp": "2026-01-17T09:54:39Z"
+      },
+      {
+        "version": "1.0.14",
+        "changelog": "Release 1.0.14",
+        "targetAbi": "10.9.0.0",
+        "sourceUrl": "https://gitea.tourolle.paris/dtourolle/jellyfin-srfPlay/releases/download/v1.0.14/srfplay_1.0.14.0.zip",
+        "checksum": "49e6afe16f7abf95c099ecc1d016e725",
+        "timestamp": "2025-12-30T12:38:41Z"
+      },
+      {
+        "version": "1.0.13",
+        "changelog": "Release 1.0.13",
+        "targetAbi": "10.9.0.0",
+        "sourceUrl": "https://gitea.tourolle.paris/dtourolle/jellyfin-srfPlay/releases/download/v1.0.13/srfplay_1.0.13.0.zip",
+        "checksum": "ac7c1e33c926c21f8e4319da91ef079c",
+        "timestamp": "2025-12-21T13:02:37Z"
+      },
+      {
+        "version": "1.0.12",
+        "changelog": "Release 1.0.12",
+        "targetAbi": "10.9.0.0",
+        "sourceUrl": "https://gitea.tourolle.paris/dtourolle/jellyfin-srfPlay/releases/download/v1.0.12/srfplay_1.0.12.0.zip",
+        "checksum": "47baa02ade413253db94fe3ba0763f69",
+        "timestamp": "2025-12-20T13:35:38Z"
+      }
+    ]
+  }
+]