Update dependency BitFaster.Caching to 2.6.0

Translation: Jellyfin/Jellyfin
Translate-URL: https://translate.jellyfin.org/projects/jellyfin/jellyfin-core/et/

.config/dotnet-tools.json

@@ -3,7 +3,7 @@
   "isRoot": true,
   "tools": {
     "dotnet-ef": {
-      "version": "9.0.11",
+      "version": "10.0.8",
       "commands": [
         "dotnet-ef"
       ]

.devcontainer/devcontainer.json

@@ -1,17 +1,31 @@
 {
     "name": "Development Jellyfin Server",
-    "image": "mcr.microsoft.com/devcontainers/dotnet:9.0-bookworm",
+    "image": "mcr.microsoft.com/devcontainers/dotnet:10.0-noble",
     "service": "app",
     "workspaceFolder": "/workspaces/${localWorkspaceFolderBasename}",
     // restores nuget packages, installs the dotnet workloads and installs the dev https certificate
     "postStartCommand": "sudo dotnet restore; sudo dotnet workload update; sudo dotnet dev-certs https --trust; sudo bash \"./.devcontainer/install-ffmpeg.sh\"",
-    // reads the extensions list and installs them
+    // The previous way of installing extensions via the vs command dont work on selfhosted devcontainers
-    "postAttachCommand": "cat .vscode/extensions.json | jq -r .recommendations[] | xargs -n 1 code --install-extension",
+    "customizations": {
+        "vscode": {
+            "extensions": [
+                "ms-dotnettools.csharp",
+                "editorconfig.editorconfig",
+                "github.vscode-github-actions",
+                "ms-dotnettools.vscode-dotnet-runtime",
+                "ms-dotnettools.csdevkit",
+                "alexcvzz.vscode-sqlite",
+                "streetsidesoftware.code-spell-checker",
+                "eamodio.gitlens",
+                "redhat.vscode-xml"
+            ]
+        }
+    },
     "features": {
         "ghcr.io/devcontainers/features/dotnet:2": {
             "version": "none",
-            "dotnetRuntimeVersions": "9.0",
+            "dotnetRuntimeVersions": "10.0",
-            "aspNetCoreRuntimeVersions": "9.0"
+            "aspNetCoreRuntimeVersions": "10.0"
         },
         "ghcr.io/devcontainers-extra/features/apt-packages:1": {
             "preserve_apt_list": false,

.editorconfig

@@ -379,6 +379,9 @@ dotnet_diagnostic.CA1720.severity = suggestion
 # disable warning CA1724: Type names should not match namespaces
 dotnet_diagnostic.CA1724.severity = suggestion
 
+# disable warning CA1873: Avoid potentially expensive logging
+dotnet_diagnostic.CA1873.severity = suggestion
+
 # disable warning CA1805: Do not initialize unnecessarily
 dotnet_diagnostic.CA1805.severity = suggestion
 
@@ -400,6 +403,10 @@ dotnet_diagnostic.CA1861.severity = suggestion
 # disable warning CA2000: Dispose objects before losing scope
 dotnet_diagnostic.CA2000.severity = suggestion
 
+# TODO: Reevaluate when false positives are fixed: https://github.com/dotnet/roslyn-analyzers/issues/7699
+# disable warning CA2025: Do not pass 'IDisposable' instances into unawaited tasks
+dotnet_diagnostic.CA2025.severity = suggestion
+
 # disable warning CA2253: Named placeholders should not be numeric values
 dotnet_diagnostic.CA2253.severity = suggestion
 

.github/CODEOWNERS

@@ -1,4 +1,11 @@
-# Joshua must review all changes to deployment and build.sh
+# Joshua must review all changes to bump_version and any files it touches
-.ci/*           @joshuaboniface
+bump_version                                            @joshuaboniface
-deployment/*    @joshuaboniface
+.github/ISSUE_TEMPLATE                                  @joshuaboniface
-build.sh        @joshuaboniface
+MediaBrowser.Common/MediaBrowser.Common.csproj          @joshuaboniface
+Jellyfin.Data/Jellyfin.Data.csproj                      @joshuaboniface
+MediaBrowser.Controller/MediaBrowser.Controller.csproj  @joshuaboniface
+MediaBrowser.Model/MediaBrowser.Model.csproj            @joshuaboniface
+Emby.Naming/Emby.Naming.csproj                          @joshuaboniface
+src/Jellyfin.Extensions/Jellyfin.Extensions.csproj      @joshuaboniface
+# Core must approve all changes within the repo config
+.github/                                                @jellyfin/core

.github/ISSUE_TEMPLATE/issue report.yml

@@ -87,7 +87,9 @@ body:
       label: Jellyfin Server version
       description: What version of Jellyfin are you using?
       options:
-        - 10.10.0+
+        - 10.11.8
+        - 10.11.7
+        - 10.11.6
         - Master
         - Unstable
         - Older*
@@ -136,13 +138,14 @@ body:
         - **FFmpeg Version**: [e.g. 5.1.2-Jellyfin]
         - **Playback**: [Direct Play, Remux, Direct Stream, Transcode]
         - **Hardware Acceleration**: [e.g. none, VAAPI, NVENC, etc.]
+        - **CPU Model**: [e.g. AMD Ryzen 5 9600X, Intel Core i7-8565U, etc.]
         - **GPU Model**: [e.g. none, UHD630, GTX1050, etc.]
         - **Installed Plugins**: [e.g. none, Fanart, Anime, etc.]
         - **Reverse Proxy**: [e.g. none, nginx, apache, etc.]
         - **Base URL**: [e.g. none, yes: /example]
         - **Networking**: [e.g. Host, Bridge/NAT]
-        - **Jellyfin Data Storage**: [e.g. local SATA SSD, local HDD]
+        - **Jellyfin Data Storage & Filesystem**: [e.g. local SATA SSD - ext4, local HDD - NTFS]
-        - **Media Storage**: [e.g. Local HDD, SMB Share]
+        - **Media Storage & Filesystem**: [e.g. Local HDD - ext4, SMB Share]
         - **External Integrations**: [e.g. Jellystat, Jellyseerr]
       value: |
         - OS:
@@ -153,13 +156,14 @@ body:
         - FFmpeg Version:
         - Playback Method:
         - Hardware Acceleration:
+        - CPU Model:
         - GPU Model:
         - Plugins:
         - Reverse Proxy:
         - Base URL:
         - Networking:
-        - Jellyfin Data Storage:
+        - Jellyfin Data Storage & Filesystem:
-        - Media Storage:
+        - Media Storage & Filesystem:
         - External Integrations:
       render: markdown
     validations:

.github/workflows/ci-codeql-analysis.yml

@@ -8,6 +8,10 @@ on:
   schedule:
     - cron: '24 2 * * 4'
 
+permissions:
+  contents: read
+  security-events: write
+
 jobs:
   analyze:
     name: Analyze
@@ -20,18 +24,21 @@ jobs:
 
     steps:
     - name: Checkout repository
-      uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
+      uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+
     - name: Setup .NET
-      uses: actions/setup-dotnet@2016bd2012dba4e32de620c46fe006a3ac9f0602 # v5.0.1
+      uses: actions/setup-dotnet@c2fa09f4bde5ebb9d1777cf28262a3eb3db3ced7 # v5.2.0
       with:
-        dotnet-version: '9.0.x'
+        dotnet-version: '10.0.x'
 
     - name: Initialize CodeQL
-      uses: github/codeql-action/init@fe4161a26a8629af62121b670040955b330f9af2 # v4.31.6
+      uses: github/codeql-action/init@9e0d7b8d25671d64c341c19c0152d693099fb5ba # v4.35.5
       with:
         languages: ${{ matrix.language }}
         queries: +security-extended
+
     - name: Autobuild
-      uses: github/codeql-action/autobuild@fe4161a26a8629af62121b670040955b330f9af2 # v4.31.6
+      uses: github/codeql-action/autobuild@9e0d7b8d25671d64c341c19c0152d693099fb5ba # v4.35.5
+
     - name: Perform CodeQL Analysis
-      uses: github/codeql-action/analyze@fe4161a26a8629af62121b670040955b330f9af2 # v4.31.6
+      uses: github/codeql-action/analyze@9e0d7b8d25671d64c341c19c0152d693099fb5ba # v4.35.5

.github/workflows/ci-compat.yml

@@ -11,22 +11,22 @@ jobs:
     permissions: read-all
     steps:
       - name: Checkout repository
-        uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
         with:
           ref: ${{ github.event.pull_request.head.sha }}
           repository: ${{ github.event.pull_request.head.repo.full_name }}
 
       - name: Setup .NET
-        uses: actions/setup-dotnet@2016bd2012dba4e32de620c46fe006a3ac9f0602 # v5.0.1
+        uses: actions/setup-dotnet@c2fa09f4bde5ebb9d1777cf28262a3eb3db3ced7 # v5.2.0
         with:
-          dotnet-version: '9.0.x'
+          dotnet-version: '10.0.x'
 
       - name: Build
         run: |
           dotnet build Jellyfin.Server -o ./out
 
       - name: Upload Head
-        uses: actions/upload-artifact@330a01c490aca151604b8cf639adc76d48f6c5d4 # v5.0.0
+        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
         with:
           name: abi-head
           retention-days: 14
@@ -40,16 +40,16 @@ jobs:
     permissions: read-all
     steps:
       - name: Checkout repository
-        uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
         with:
           ref: ${{ github.event.pull_request.head.sha }}
           repository: ${{ github.event.pull_request.head.repo.full_name }}
           fetch-depth: 0
 
       - name: Setup .NET
-        uses: actions/setup-dotnet@2016bd2012dba4e32de620c46fe006a3ac9f0602 # v5.0.1
+        uses: actions/setup-dotnet@c2fa09f4bde5ebb9d1777cf28262a3eb3db3ced7 # v5.2.0
         with:
-          dotnet-version: '9.0.x'
+          dotnet-version: '10.0.x'
 
       - name: Checkout common ancestor
         env:
@@ -65,7 +65,7 @@ jobs:
           dotnet build Jellyfin.Server -o ./out
 
       - name: Upload Head
-        uses: actions/upload-artifact@330a01c490aca151604b8cf639adc76d48f6c5d4 # v5.0.0
+        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
         with:
           name: abi-base
           retention-days: 14
@@ -85,13 +85,13 @@ jobs:
 
     steps:
       - name: Download abi-head
-        uses: actions/download-artifact@018cc2cf5baa6db3ef3c5f8a56943fffe632ef53 # v6.0.0
+        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
         with:
           name: abi-head
           path: abi-head
 
       - name: Download abi-base
-        uses: actions/download-artifact@018cc2cf5baa6db3ef3c5f8a56943fffe632ef53 # v6.0.0
+        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
         with:
           name: abi-base
           path: abi-base
@@ -106,7 +106,7 @@ jobs:
           {
             echo 'body<<EOF'
             for file in Jellyfin.Data.dll MediaBrowser.Common.dll MediaBrowser.Controller.dll MediaBrowser.Model.dll Emby.Naming.dll Jellyfin.Extensions.dll Jellyfin.MediaEncoding.Keyframes.dll Jellyfin.Database.Implementations.dll; do
-              COMPAT_OUTPUT="$( { apicompat --left ./abi-base/${file} --right ./abi-head/${file}; } 2>&1 )"
+              COMPAT_OUTPUT="$( { apicompat --left ./abi-base/${file} --right ./abi-head/${file}; } 2>&1 || true )"
               if [ "APICompat ran successfully without finding any breaking changes." != "${COMPAT_OUTPUT}" ]; then
                 printf "\n${file}\n${COMPAT_OUTPUT}\n"
               fi

.github/workflows/ci-openapi.yml

@@ -1,271 +0,0 @@
-name: OpenAPI
-on:
-  push:
-    branches:
-      - master
-    tags:
-      - 'v*'
-  pull_request:
-
-permissions: {}
-
-jobs:
-  openapi-head:
-    name: OpenAPI - HEAD
-    runs-on: ubuntu-latest
-    permissions: read-all
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
-        with:
-          ref: ${{ github.event.pull_request.head.sha }}
-          repository: ${{ github.event.pull_request.head.repo.full_name }}
-      - name: Setup .NET
-        uses: actions/setup-dotnet@2016bd2012dba4e32de620c46fe006a3ac9f0602 # v5.0.1
-        with:
-          dotnet-version: '9.0.x'
-      - name: Generate openapi.json
-        run: dotnet test tests/Jellyfin.Server.Integration.Tests/Jellyfin.Server.Integration.Tests.csproj -c Release --filter "Jellyfin.Server.Integration.Tests.OpenApiSpecTests"
-      - name: Upload openapi.json
-        uses: actions/upload-artifact@330a01c490aca151604b8cf639adc76d48f6c5d4 # v5.0.0
-        with:
-          name: openapi-head
-          retention-days: 14
-          if-no-files-found: error
-          path: tests/Jellyfin.Server.Integration.Tests/bin/Release/net9.0/openapi.json
-
-  openapi-base:
-    name: OpenAPI - BASE
-    if: ${{ github.base_ref != '' }}
-    runs-on: ubuntu-latest
-    permissions: read-all
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
-        with:
-          ref: ${{ github.event.pull_request.head.sha }}
-          repository: ${{ github.event.pull_request.head.repo.full_name }}
-          fetch-depth: 0
-      - name: Checkout common ancestor
-        env:
-          HEAD_REF: ${{ github.head_ref }}
-        run: |
-          git remote add upstream https://github.com/${{ github.event.pull_request.base.repo.full_name }}
-          git -c protocol.version=2 fetch --prune --progress --no-recurse-submodules upstream +refs/heads/*:refs/remotes/upstream/* +refs/tags/*:refs/tags/*
-          ANCESTOR_REF=$(git merge-base upstream/${{ github.base_ref }} origin/$HEAD_REF)
-          git checkout --progress --force $ANCESTOR_REF
-      - name: Setup .NET
-        uses: actions/setup-dotnet@2016bd2012dba4e32de620c46fe006a3ac9f0602 # v5.0.1
-        with:
-          dotnet-version: '9.0.x'
-      - name: Generate openapi.json
-        run: dotnet test tests/Jellyfin.Server.Integration.Tests/Jellyfin.Server.Integration.Tests.csproj -c Release --filter "Jellyfin.Server.Integration.Tests.OpenApiSpecTests"
-      - name: Upload openapi.json
-        uses: actions/upload-artifact@330a01c490aca151604b8cf639adc76d48f6c5d4 # v5.0.0
-        with:
-          name: openapi-base
-          retention-days: 14
-          if-no-files-found: error
-          path: tests/Jellyfin.Server.Integration.Tests/bin/Release/net9.0/openapi.json
-
-  openapi-diff:
-    permissions:
-      pull-requests: write  #  to create or update comment (peter-evans/create-or-update-comment)
-
-    name: OpenAPI - Difference
-    if: ${{ github.event_name == 'pull_request' }}
-    runs-on: ubuntu-latest
-    needs:
-      - openapi-head
-      - openapi-base
-    steps:
-      - name: Download openapi-head
-        uses: actions/download-artifact@018cc2cf5baa6db3ef3c5f8a56943fffe632ef53 # v6.0.0
-        with:
-          name: openapi-head
-          path: openapi-head
-      - name: Download openapi-base
-        uses: actions/download-artifact@018cc2cf5baa6db3ef3c5f8a56943fffe632ef53 # v6.0.0
-        with:
-          name: openapi-base
-          path: openapi-base
-      - name: Workaround openapi-diff issue
-        run: |
-          sed -i 's/"allOf"/"oneOf"/g' openapi-head/openapi.json
-          sed -i 's/"allOf"/"oneOf"/g' openapi-base/openapi.json
-      - name: Calculate OpenAPI difference
-        uses: docker://openapitools/openapi-diff
-        continue-on-error: true
-        with:
-          args: --fail-on-changed --markdown openapi-changes.md openapi-base/openapi.json openapi-head/openapi.json
-      - id: read-diff
-        name: Read openapi-diff output
-        run: |
-          # Read and fix markdown
-          body=$(cat openapi-changes.md)
-          # Write to workflow summary
-          echo "$body" >> $GITHUB_STEP_SUMMARY
-          # Set ApiChanged var
-          if [ "$body" != '' ]; then
-            echo "ApiChanged=1" >> "$GITHUB_OUTPUT"
-          else
-            echo "ApiChanged=0" >> "$GITHUB_OUTPUT"
-          fi
-          # Add header/footer for diff comment
-          echo '<!--openapi-diff-workflow-comment-->' > openapi-changes-reply.md
-          echo "<details>" >> openapi-changes-reply.md
-          echo "<summary>Changes in OpenAPI specification found. Expand to see details.</summary>" >> openapi-changes-reply.md
-          echo "" >> openapi-changes-reply.md
-          echo "$body" >> openapi-changes-reply.md
-          echo "" >> openapi-changes-reply.md
-          echo "</details>" >> openapi-changes-reply.md
-      - name: Find difference comment
-        uses: peter-evans/find-comment@b30e6a3c0ed37e7c023ccd3f1db5c6c0b0c23aad # v4.0.0
-        id: find-comment
-        with:
-          issue-number: ${{ github.event.pull_request.number }}
-          direction: last
-          body-includes: openapi-diff-workflow-comment
-      - name: Reply or edit difference comment (changed)
-        uses: peter-evans/create-or-update-comment@e8674b075228eee787fea43ef493e45ece1004c9 # v5.0.0
-        if: ${{ steps.read-diff.outputs.ApiChanged == '1' }}
-        with:
-          issue-number: ${{ github.event.pull_request.number }}
-          comment-id: ${{ steps.find-comment.outputs.comment-id }}
-          edit-mode: replace
-          body-path: openapi-changes-reply.md
-      - name: Edit difference comment (unchanged)
-        uses: peter-evans/create-or-update-comment@e8674b075228eee787fea43ef493e45ece1004c9 # v5.0.0
-        if: ${{ steps.read-diff.outputs.ApiChanged == '0' && steps.find-comment.outputs.comment-id != '' }}
-        with:
-          issue-number: ${{ github.event.pull_request.number }}
-          comment-id: ${{ steps.find-comment.outputs.comment-id }}
-          edit-mode: replace
-          body: |
-            <!--openapi-diff-workflow-comment-->
-
-            No changes to OpenAPI specification found. See history of this comment for previous changes.
-
-  publish-unstable:
-    name: OpenAPI - Publish Unstable Spec
-    if: ${{ github.event_name != 'pull_request' && !startsWith(github.ref, 'refs/tags/v') && contains(github.repository_owner, 'jellyfin') }}
-    runs-on: ubuntu-latest
-    needs:
-      - openapi-head
-    steps:
-      - name: Set unstable dated version
-        id: version
-        run: |-
-          echo "JELLYFIN_VERSION=$(date +'%Y%m%d%H%M%S')" >> $GITHUB_ENV
-      - name: Download openapi-head
-        uses: actions/download-artifact@018cc2cf5baa6db3ef3c5f8a56943fffe632ef53 # v6.0.0
-        with:
-          name: openapi-head
-          path: openapi-head
-      - name: Upload openapi.json (unstable) to repository server
-        uses: appleboy/scp-action@ff85246acaad7bdce478db94a363cd2bf7c90345 # v1.0.0
-        with:
-          host: "${{ secrets.REPO_HOST }}"
-          username: "${{ secrets.REPO_USER }}"
-          key: "${{ secrets.REPO_KEY }}"
-          source: openapi-head/openapi.json
-          strip_components: 1
-          target: "/srv/incoming/openapi/unstable/jellyfin-openapi-${{ env.JELLYFIN_VERSION }}"
-      - name: Move openapi.json (unstable) into place
-        uses: appleboy/ssh-action@823bd89e131d8d508129f9443cad5855e9ba96f0 # v1.2.4
-        with:
-          host: "${{ secrets.REPO_HOST }}"
-          username: "${{ secrets.REPO_USER }}"
-          key: "${{ secrets.REPO_KEY }}"
-          debug: false
-          script_stop: false
-          script: |
-            if ! test -d /run/workflows; then
-                sudo mkdir -p /run/workflows
-                sudo chown ${{ secrets.REPO_USER }} /run/workflows
-            fi
-            (
-            flock -x -w 300 200 || exit 1
-            TGT_DIR="/srv/repository/main/openapi"
-            LAST_SPEC="$( ls -lt ${TGT_DIR}/unstable/ | grep 'jellyfin-openapi' | head -1 | awk '{ print $NF }' )"
-            # If new and previous spec don't differ (diff retcode 0), remove incoming and finish
-            if diff /srv/incoming/openapi/unstable/jellyfin-openapi-${{ env.JELLYFIN_VERSION }}/openapi.json ${TGT_DIR}/unstable/${LAST_SPEC} &>/dev/null; then
-                rm -r /srv/incoming/openapi/unstable/jellyfin-openapi-${{ env.JELLYFIN_VERSION }}
-                exit 0
-            fi
-            # Move new spec into place
-            sudo mv /srv/incoming/openapi/unstable/jellyfin-openapi-${{ env.JELLYFIN_VERSION }}/openapi.json ${TGT_DIR}/unstable/jellyfin-openapi-${{ env.JELLYFIN_VERSION }}.json
-            # Delete previous jellyfin-openapi-unstable_previous.json
-            sudo rm ${TGT_DIR}/jellyfin-openapi-unstable_previous.json
-            # Move current jellyfin-openapi-unstable.json symlink to jellyfin-openapi-unstable_previous.json
-            sudo mv ${TGT_DIR}/jellyfin-openapi-unstable.json ${TGT_DIR}/jellyfin-openapi-unstable_previous.json
-            # Create new jellyfin-openapi-unstable.json symlink
-            sudo ln -s unstable/jellyfin-openapi-${{ env.JELLYFIN_VERSION }}.json ${TGT_DIR}/jellyfin-openapi-unstable.json
-            # Check that the previous openapi unstable spec link is correct
-            if [[ "$( readlink ${TGT_DIR}/jellyfin-openapi-unstable_previous.json )" != "unstable/${LAST_SPEC}" ]]; then
-                sudo rm ${TGT_DIR}/jellyfin-openapi-unstable_previous.json
-                sudo ln -s unstable/${LAST_SPEC} ${TGT_DIR}/jellyfin-openapi-unstable_previous.json
-            fi
-            ) 200>/run/workflows/openapi-unstable.lock
-
-  publish-stable:
-    name: OpenAPI - Publish Stable Spec
-    if: ${{ startsWith(github.ref, 'refs/tags/v') && contains(github.repository_owner, 'jellyfin') }}
-    runs-on: ubuntu-latest
-    needs:
-      - openapi-head
-    steps:
-      - name: Set version number
-        id: version
-        run: |-
-          echo "JELLYFIN_VERSION=${GITHUB_REF#refs/tags/v}" >> $GITHUB_ENV
-      - name: Download openapi-head
-        uses: actions/download-artifact@018cc2cf5baa6db3ef3c5f8a56943fffe632ef53 # v6.0.0
-        with:
-          name: openapi-head
-          path: openapi-head
-      - name: Upload openapi.json (stable) to repository server
-        uses: appleboy/scp-action@ff85246acaad7bdce478db94a363cd2bf7c90345 # v1.0.0
-        with:
-          host: "${{ secrets.REPO_HOST }}"
-          username: "${{ secrets.REPO_USER }}"
-          key: "${{ secrets.REPO_KEY }}"
-          source: openapi-head/openapi.json
-          strip_components: 1
-          target: "/srv/incoming/openapi/stable/jellyfin-openapi-${{ env.JELLYFIN_VERSION }}"
-      - name: Move openapi.json (stable) into place
-        uses: appleboy/ssh-action@823bd89e131d8d508129f9443cad5855e9ba96f0 # v1.2.4
-        with:
-          host: "${{ secrets.REPO_HOST }}"
-          username: "${{ secrets.REPO_USER }}"
-          key: "${{ secrets.REPO_KEY }}"
-          debug: false
-          script_stop: false
-          script: |
-            if ! test -d /run/workflows; then
-                sudo mkdir -p /run/workflows
-                sudo chown ${{ secrets.REPO_USER }} /run/workflows
-            fi
-            (
-            flock -x -w 300 200 || exit 1
-            TGT_DIR="/srv/repository/main/openapi"
-            LAST_SPEC="$( ls -lt ${TGT_DIR}/stable/ | grep 'jellyfin-openapi' | head -1 | awk '{ print $NF }' )"
-            # If new and previous spec don't differ (diff retcode 0), remove incoming and finish
-            if diff /srv/incoming/openapi/stable/jellyfin-openapi-${{ env.JELLYFIN_VERSION }}/openapi.json ${TGT_DIR}/stable/${LAST_SPEC} &>/dev/null; then
-                rm -r /srv/incoming/openapi/stable/jellyfin-openapi-${{ env.JELLYFIN_VERSION }}
-                exit 0
-            fi
-            # Move new spec into place
-            sudo mv /srv/incoming/openapi/stable/jellyfin-openapi-${{ env.JELLYFIN_VERSION }}/openapi.json ${TGT_DIR}/stable/jellyfin-openapi-${{ env.JELLYFIN_VERSION }}.json
-            # Delete previous jellyfin-openapi-stable_previous.json
-            sudo rm ${TGT_DIR}/jellyfin-openapi-stable_previous.json
-            # Move current jellyfin-openapi-stable.json symlink to jellyfin-openapi-stable_previous.json
-            sudo mv ${TGT_DIR}/jellyfin-openapi-stable.json ${TGT_DIR}/jellyfin-openapi-stable_previous.json
-            # Create new jellyfin-openapi-stable.json symlink
-            sudo ln -s stable/jellyfin-openapi-${{ env.JELLYFIN_VERSION }}.json ${TGT_DIR}/jellyfin-openapi-stable.json
-            # Check that the previous openapi stable spec link is correct
-            if [[ "$( readlink ${TGT_DIR}/jellyfin-openapi-stable_previous.json )" != "stable/${LAST_SPEC}" ]]; then
-                sudo rm ${TGT_DIR}/jellyfin-openapi-stable_previous.json
-                sudo ln -s stable/${LAST_SPEC} ${TGT_DIR}/jellyfin-openapi-stable_previous.json
-            fi
-            ) 200>/run/workflows/openapi-stable.lock

.github/workflows/ci-tests.yml

@@ -9,7 +9,7 @@ on:
   pull_request:
 
 env:
-  SDK_VERSION: "9.0.x"
+  SDK_VERSION: "10.0.x"
 
 jobs:
   run-tests:
@@ -20,9 +20,9 @@ jobs:
 
     runs-on: "${{ matrix.os }}"
     steps:
-      - uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
 
-      - uses: actions/setup-dotnet@2016bd2012dba4e32de620c46fe006a3ac9f0602 # v5.0.1
+      - uses: actions/setup-dotnet@c2fa09f4bde5ebb9d1777cf28262a3eb3db3ced7 # v5.2.0
         with:
           dotnet-version: ${{ env.SDK_VERSION }}
 
@@ -35,7 +35,7 @@ jobs:
           --verbosity minimal
 
       - name: Merge code coverage results
-        uses: danielpalme/ReportGenerator-GitHub-Action@ee0ae774f6d3afedcbd1683c1ab21b83670bdf8e # v5.5.1
+        uses: danielpalme/ReportGenerator-GitHub-Action@049f7ec958c672fd31d5cc1cb01622dc8d2e23ab # v5.5.10
         with:
           reports: "**/coverage.cobertura.xml"
           targetdir: "merged/"

.github/workflows/commands.yml

@@ -24,7 +24,7 @@ jobs:
           reactions: '+1'
 
       - name: Checkout the latest code
-        uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
         with:
           token: ${{ secrets.JF_BOT_TOKEN }}
           fetch-depth: 0
@@ -36,20 +36,23 @@ jobs:
 
   rename:
     name: Rename
-    if: contains(github.event.comment.body, '@jellyfin-bot rename') && github.event.comment.author_association == 'MEMBER'
+    if: contains(github.event.comment.body, '@jellyfin-bot rename')
     runs-on: ubuntu-latest
     steps:
       - name: pull in script
-        uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
         with:
           repository: jellyfin/jellyfin-triage-script
+
       - name: install python
-        uses: actions/setup-python@83679a892e2d95755f2dac6acb0bfd1e9ac5d548 # v6.1.0
+        uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
         with:
           python-version: '3.14'
           cache: 'pip'
+
       - name: install python packages
         run: pip install -r rename/requirements.txt
+
       - name: run rename script
         run: python3 rename.py
         working-directory: ./rename

.github/workflows/issue-stale.yml

@@ -16,7 +16,7 @@ jobs:
     runs-on: ubuntu-latest
     if: ${{ contains(github.repository, 'jellyfin/') }}
     steps:
-      - uses: actions/stale@997185467fa4f803885201cee163a9f38240193d # v10.1.1
+      - uses: actions/stale@b5d41d4e1d5dceea10e7104786b73624c18a190f # v10.2.0
         with:
           repo-token: ${{ secrets.JF_BOT_TOKEN }}
           ascending: true

.github/workflows/issue-template-check.yml

@@ -10,16 +10,19 @@ jobs:
       issues: write
     steps:
       - name: pull in script
-        uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
         with:
           repository: jellyfin/jellyfin-triage-script
+
       - name: install python
-        uses: actions/setup-python@83679a892e2d95755f2dac6acb0bfd1e9ac5d548 # v6.1.0
+        uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
         with:
           python-version: '3.14'
           cache: 'pip'
+
       - name: install python packages
         run: pip install -r main-repo-triage/requirements.txt
+
       - name: check and comment issue
         working-directory: ./main-repo-triage
         run: python3 single_issue_gha.py

.github/workflows/openapi-generate.yml

@@ -0,0 +1,44 @@
+name: OpenAPI Generate
+
+on:
+  workflow_call:
+    inputs:
+      ref:
+        required: true
+        type: string
+      repository:
+        required: true
+        type: string
+      artifact:
+        required: true
+        type: string
+
+permissions:
+  contents: read
+
+jobs:
+  main:
+    name: Main
+    runs-on: ubuntu-latest
+    steps:
+    - name: Checkout Repository
+      uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+      with:
+        ref: ${{ inputs.ref }}
+        repository: ${{ inputs.repository }}
+
+    - name: Configure .NET
+      uses: actions/setup-dotnet@c2fa09f4bde5ebb9d1777cf28262a3eb3db3ced7 # v5.2.0
+      with:
+        dotnet-version: '10.0.x'
+
+    - name: Create File
+      run: dotnet test tests/Jellyfin.Server.Integration.Tests/Jellyfin.Server.Integration.Tests.csproj -c Release --filter Jellyfin.Server.Integration.Tests.OpenApiSpecTests
+
+    - name: Upload Artifact
+      uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+      with:
+        name: ${{ inputs.artifact }}
+        path: tests/Jellyfin.Server.Integration.Tests/bin/Release/net10.0/openapi.json
+        retention-days: 14
+        if-no-files-found: error

.github/workflows/openapi-merge.yml

@@ -0,0 +1,140 @@
+name: OpenAPI Publish
+on:
+  push:
+    branches:
+      - master
+    tags:
+      - 'v*'
+
+jobs:
+  publish-openapi:
+    name: OpenAPI - Publish Artifact
+    uses: ./.github/workflows/openapi-generate.yml
+    permissions:
+      contents: read
+    with:
+      ref: ${{ github.sha }}
+      repository: ${{ github.repository }}
+      artifact: openapi-head
+
+  publish-unstable:
+    name: OpenAPI - Publish Unstable Spec
+    if: ${{ github.event_name != 'pull_request' && !startsWith(github.ref, 'refs/tags/v') && contains(github.repository_owner, 'jellyfin') }}
+    runs-on: ubuntu-latest
+    needs:
+    - publish-openapi
+    steps:
+      - name: Set unstable dated version
+        id: version
+        run: |-
+          echo "JELLYFIN_VERSION=$(date +'%Y%m%d%H%M%S')" >> $GITHUB_ENV
+      - name: Download openapi-head
+        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
+        with:
+          name: openapi-head
+          path: openapi-head
+      - name: Upload openapi.json (unstable) to repository server
+        uses: appleboy/scp-action@ff85246acaad7bdce478db94a363cd2bf7c90345 # v1.0.0
+        with:
+          host: "${{ secrets.REPO_HOST }}"
+          username: "${{ secrets.REPO_USER }}"
+          key: "${{ secrets.REPO_KEY }}"
+          source: openapi-head/openapi.json
+          strip_components: 1
+          target: "/srv/incoming/openapi/unstable/jellyfin-openapi-${{ env.JELLYFIN_VERSION }}"
+      - name: Move openapi.json (unstable) into place
+        uses: appleboy/ssh-action@0ff4204d59e8e51228ff73bce53f80d53301dee2 # v1.2.5
+        with:
+          host: "${{ secrets.REPO_HOST }}"
+          username: "${{ secrets.REPO_USER }}"
+          key: "${{ secrets.REPO_KEY }}"
+          debug: false
+          script: |
+            if ! test -d /run/workflows; then
+                sudo mkdir -p /run/workflows
+                sudo chown ${{ secrets.REPO_USER }} /run/workflows
+            fi
+            (
+            flock -x -w 300 200 || exit 1
+            TGT_DIR="/srv/repository/main/openapi"
+            LAST_SPEC="$( ls -lt ${TGT_DIR}/unstable/ | grep 'jellyfin-openapi' | head -1 | awk '{ print $NF }' )"
+            # If new and previous spec don't differ (diff retcode 0), remove incoming and finish
+            if diff /srv/incoming/openapi/unstable/jellyfin-openapi-${{ env.JELLYFIN_VERSION }}/openapi.json ${TGT_DIR}/unstable/${LAST_SPEC} &>/dev/null; then
+                rm -r /srv/incoming/openapi/unstable/jellyfin-openapi-${{ env.JELLYFIN_VERSION }}
+                exit 0
+            fi
+            # Move new spec into place
+            sudo mv /srv/incoming/openapi/unstable/jellyfin-openapi-${{ env.JELLYFIN_VERSION }}/openapi.json ${TGT_DIR}/unstable/jellyfin-openapi-${{ env.JELLYFIN_VERSION }}.json
+            # Delete previous jellyfin-openapi-unstable_previous.json
+            sudo rm ${TGT_DIR}/jellyfin-openapi-unstable_previous.json
+            # Move current jellyfin-openapi-unstable.json symlink to jellyfin-openapi-unstable_previous.json
+            sudo mv ${TGT_DIR}/jellyfin-openapi-unstable.json ${TGT_DIR}/jellyfin-openapi-unstable_previous.json
+            # Create new jellyfin-openapi-unstable.json symlink
+            sudo ln -s unstable/jellyfin-openapi-${{ env.JELLYFIN_VERSION }}.json ${TGT_DIR}/jellyfin-openapi-unstable.json
+            # Check that the previous openapi unstable spec link is correct
+            if [[ "$( readlink ${TGT_DIR}/jellyfin-openapi-unstable_previous.json )" != "unstable/${LAST_SPEC}" ]]; then
+                sudo rm ${TGT_DIR}/jellyfin-openapi-unstable_previous.json
+                sudo ln -s unstable/${LAST_SPEC} ${TGT_DIR}/jellyfin-openapi-unstable_previous.json
+            fi
+            ) 200>/run/workflows/openapi-unstable.lock
+
+  publish-stable:
+    name: OpenAPI - Publish Stable Spec
+    if: ${{ startsWith(github.ref, 'refs/tags/v') && contains(github.repository_owner, 'jellyfin') }}
+    runs-on: ubuntu-latest
+    needs:
+    - publish-openapi
+    steps:
+      - name: Set version number
+        id: version
+        run: |-
+          echo "JELLYFIN_VERSION=${GITHUB_REF#refs/tags/v}" >> $GITHUB_ENV
+      - name: Download openapi-head
+        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
+        with:
+          name: openapi-head
+          path: openapi-head
+      - name: Upload openapi.json (stable) to repository server
+        uses: appleboy/scp-action@ff85246acaad7bdce478db94a363cd2bf7c90345 # v1.0.0
+        with:
+          host: "${{ secrets.REPO_HOST }}"
+          username: "${{ secrets.REPO_USER }}"
+          key: "${{ secrets.REPO_KEY }}"
+          source: openapi-head/openapi.json
+          strip_components: 1
+          target: "/srv/incoming/openapi/stable/jellyfin-openapi-${{ env.JELLYFIN_VERSION }}"
+      - name: Move openapi.json (stable) into place
+        uses: appleboy/ssh-action@0ff4204d59e8e51228ff73bce53f80d53301dee2 # v1.2.5
+        with:
+          host: "${{ secrets.REPO_HOST }}"
+          username: "${{ secrets.REPO_USER }}"
+          key: "${{ secrets.REPO_KEY }}"
+          debug: false
+          script: |
+            if ! test -d /run/workflows; then
+                sudo mkdir -p /run/workflows
+                sudo chown ${{ secrets.REPO_USER }} /run/workflows
+            fi
+            (
+            flock -x -w 300 200 || exit 1
+            TGT_DIR="/srv/repository/main/openapi"
+            LAST_SPEC="$( ls -lt ${TGT_DIR}/stable/ | grep 'jellyfin-openapi' | head -1 | awk '{ print $NF }' )"
+            # If new and previous spec don't differ (diff retcode 0), remove incoming and finish
+            if diff /srv/incoming/openapi/stable/jellyfin-openapi-${{ env.JELLYFIN_VERSION }}/openapi.json ${TGT_DIR}/stable/${LAST_SPEC} &>/dev/null; then
+                rm -r /srv/incoming/openapi/stable/jellyfin-openapi-${{ env.JELLYFIN_VERSION }}
+                exit 0
+            fi
+            # Move new spec into place
+            sudo mv /srv/incoming/openapi/stable/jellyfin-openapi-${{ env.JELLYFIN_VERSION }}/openapi.json ${TGT_DIR}/stable/jellyfin-openapi-${{ env.JELLYFIN_VERSION }}.json
+            # Delete previous jellyfin-openapi-stable_previous.json
+            sudo rm ${TGT_DIR}/jellyfin-openapi-stable_previous.json
+            # Move current jellyfin-openapi-stable.json symlink to jellyfin-openapi-stable_previous.json
+            sudo mv ${TGT_DIR}/jellyfin-openapi-stable.json ${TGT_DIR}/jellyfin-openapi-stable_previous.json
+            # Create new jellyfin-openapi-stable.json symlink
+            sudo ln -s stable/jellyfin-openapi-${{ env.JELLYFIN_VERSION }}.json ${TGT_DIR}/jellyfin-openapi-stable.json
+            # Check that the previous openapi stable spec link is correct
+            if [[ "$( readlink ${TGT_DIR}/jellyfin-openapi-stable_previous.json )" != "stable/${LAST_SPEC}" ]]; then
+                sudo rm ${TGT_DIR}/jellyfin-openapi-stable_previous.json
+                sudo ln -s stable/${LAST_SPEC} ${TGT_DIR}/jellyfin-openapi-stable_previous.json
+            fi
+            ) 200>/run/workflows/openapi-stable.lock

.github/workflows/openapi-pull-request.yml

@@ -0,0 +1,80 @@
+name: OpenAPI Check
+on:
+  pull_request:
+
+jobs:
+  ancestor:
+    name: Common Ancestor
+    runs-on: ubuntu-latest
+    outputs:
+      base_ref: ${{ steps.ancestor.outputs.base_ref }}
+    steps:
+    - name: Checkout Repository
+      uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+      with:
+        ref: ${{ github.event.pull_request.head.sha }}
+        repository: ${{ github.event.pull_request.head.repo.full_name }}
+        fetch-depth: 0
+    - name: Search History
+      id: ancestor
+      run: |
+        git remote add upstream https://github.com/${{ github.event.pull_request.base.repo.full_name }}
+        git fetch --prune --progress --no-recurse-submodules upstream +refs/heads/*:refs/remotes/upstream/* +refs/tags/*:refs/tags/*
+
+        ANCESTOR_REF=$(git merge-base upstream/${{ github.base_ref }} HEAD)
+
+        echo "ref: ${ANCESTOR_REF}"
+
+        echo "base_ref=${ANCESTOR_REF}" >> "$GITHUB_OUTPUT"
+
+  head:
+    name: Head Artifact
+    uses: ./.github/workflows/openapi-generate.yml
+    with:
+      ref: ${{ github.event.pull_request.head.sha }}
+      repository: ${{ github.event.pull_request.head.repo.full_name }}
+      artifact: openapi-head
+
+  base:
+    name: Base Artifact
+    uses: ./.github/workflows/openapi-generate.yml
+    needs:
+    - ancestor
+    with:
+      ref: ${{ needs.ancestor.outputs.base_ref }}
+      repository: ${{ github.event.pull_request.base.repo.full_name }}
+      artifact: openapi-base
+
+  diff:
+    name: Generate Report
+    runs-on: ubuntu-latest
+    needs:
+    - head
+    - base
+    steps:
+    - name: Download Head
+      uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
+      with:
+        name: openapi-head
+        path: openapi-head
+    - name: Download Base
+      uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
+      with:
+        name: openapi-base
+        path: openapi-base
+    - name: Detect Changes
+      id: openapi-diff
+      run: |
+        sed -i 's:allOf:oneOf:g' openapi-head/openapi.json
+        sed -i 's:allOf:oneOf:g' openapi-base/openapi.json
+
+        mkdir -p /tmp/openapi-report
+        mv openapi-head/openapi.json /tmp/openapi-report/head.json
+        mv openapi-base/openapi.json /tmp/openapi-report/base.json
+
+        docker run -v /tmp/openapi-report:/data openapitools/openapi-diff:2.1.6 /data/base.json /data/head.json --state -l ERROR --markdown /data/openapi-report.md
+    - name: Upload Artifact
+      uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+      with:
+        name: openapi-report
+        path: /tmp/openapi-report/openapi-report.md

.github/workflows/openapi-workflow-run.yml

@@ -0,0 +1,59 @@
+name: OpenAPI Report
+
+on:
+  workflow_run:
+    workflows:
+    - OpenAPI Check
+    types:
+    - completed
+
+jobs:
+  metadata:
+    name: Generate Metadata
+    runs-on: ubuntu-latest
+    if: ${{ github.event.workflow_run.conclusion == 'success' }}
+    outputs:
+      pr_number: ${{ steps.pr_number.outputs.pr_number }}
+    steps:
+    - name: Get Pull Request Number
+      id: pr_number
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        HEAD_SHA: ${{ github.event.workflow_run.head_sha }}
+      run: |
+        API_RESPONSE=$(gh pr list --repo "${GITHUB_REPOSITORY}" --search "${HEAD_SHA}" --state open --json number)
+        PR_NUMBER=$(echo "${API_RESPONSE}" | jq '.[0].number')
+
+        echo "repository: ${GITHUB_REPOSITORY}"
+        echo "sha: ${HEAD_SHA}"
+        echo "response: ${API_RESPONSE}"
+        echo "pr: ${PR_NUMBER}"
+
+        echo "pr_number=${PR_NUMBER}" >> "${GITHUB_OUTPUT}"
+
+  comment:
+    name: Pull Request Comment
+    runs-on: ubuntu-latest
+    if: ${{ github.event.workflow_run.conclusion == 'success' }}
+    needs:
+    - metadata
+    permissions:
+      pull-requests: write
+      actions: read
+      contents: read
+    steps:
+    - name: Download OpenAPI Report
+      id: download_report
+      uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
+      with:
+        name: openapi-report
+        path: openapi-report
+        run-id: ${{ github.event.workflow_run.id }}
+        github-token: ${{ secrets.GITHUB_TOKEN }}
+    - name: Push Comment
+      uses: thollander/actions-comment-pull-request@24bffb9b452ba05a4f3f77933840a6a841d1b32b # v3.0.1
+      with:
+        github-token: ${{ secrets.JF_BOT_TOKEN }}
+        file-path: ${{ steps.download_report.outputs.download-path }}/openapi-report.md
+        pr-number: ${{ needs.metadata.outputs.pr_number }}
+        comment-tag: openapi-report

.github/workflows/project-automation.yml

@@ -21,6 +21,7 @@ jobs:
         with:
           project: Current Release
           action: delete
+          column: In progress
           repo-token: ${{ secrets.JF_BOT_TOKEN }}
 
       - name: Add to 'Release Next' project

.github/workflows/pull-request-stale.yaml

@@ -15,7 +15,7 @@ jobs:
     runs-on: ubuntu-latest
     if: ${{ contains(github.repository, 'jellyfin/') }}
     steps:
-      - uses: actions/stale@997185467fa4f803885201cee163a9f38240193d # v10.1.1
+      - uses: actions/stale@b5d41d4e1d5dceea10e7104786b73624c18a190f # v10.2.0
         with:
           repo-token: ${{ secrets.JF_BOT_TOKEN }}
           ascending: true

.github/workflows/release-bump-version.yaml

@@ -28,12 +28,12 @@ jobs:
           timeoutSeconds: 3600
 
       - name: Setup YQ
-        uses: chrisdickinson/setup-yq@latest
+        uses: chrisdickinson/setup-yq@fa3192edd79d6eb0e4e12de8dde3a0c26f2b853b # latest
         with:
           yq-version: v4.9.8
 
       - name: Checkout Repository
-        uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
         with:
           ref: ${{ env.TAG_BRANCH }}
 
@@ -66,7 +66,7 @@ jobs:
       NEXT_VERSION: ${{ github.event.inputs.NEXT_VERSION }}
     steps:
       - name: Checkout Repository
-        uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
         with:
           ref: ${{ env.TAG_BRANCH }}
 

.vscode/launch.json

@@ -6,7 +6,7 @@
             "type": "coreclr",
             "request": "launch",
             "preLaunchTask": "build",
-            "program": "${workspaceFolder}/Jellyfin.Server/bin/Debug/net9.0/jellyfin.dll",
+            "program": "${workspaceFolder}/Jellyfin.Server/bin/Debug/net10.0/jellyfin.dll",
             "args": [],
             "cwd": "${workspaceFolder}/Jellyfin.Server",
             "console": "internalConsole",
@@ -22,7 +22,7 @@
             "type": "coreclr",
             "request": "launch",
             "preLaunchTask": "build",
-            "program": "${workspaceFolder}/Jellyfin.Server/bin/Debug/net9.0/jellyfin.dll",
+            "program": "${workspaceFolder}/Jellyfin.Server/bin/Debug/net10.0/jellyfin.dll",
             "args": ["--nowebclient"],
             "cwd": "${workspaceFolder}/Jellyfin.Server",
             "console": "internalConsole",
@@ -34,7 +34,7 @@
             "type": "coreclr",
             "request": "launch",
             "preLaunchTask": "build",
-            "program": "${workspaceFolder}/Jellyfin.Server/bin/Debug/net9.0/jellyfin.dll",
+            "program": "${workspaceFolder}/Jellyfin.Server/bin/Debug/net10.0/jellyfin.dll",
             "args": ["--nowebclient", "--ffmpeg", "/usr/lib/jellyfin-ffmpeg/ffmpeg"],
             "cwd": "${workspaceFolder}/Jellyfin.Server",
             "console": "internalConsole",

CONTRIBUTORS.md

@@ -1,5 +1,6 @@
 # Jellyfin Contributors
 
+ - [0x25CBFC4F](https://github.com/0x25CBFC4F)
  - [1337joe](https://github.com/1337joe)
  - [97carmine](https://github.com/97carmine)
  - [Abbe98](https://github.com/Abbe98)
@@ -14,7 +15,7 @@
  - [bilde2910](https://github.com/bilde2910)
  - [bfayers](https://github.com/bfayers)
  - [BnMcG](https://github.com/BnMcG)
- - [Bond-009](https://github.com/Bond-009)
+ - [Bond_009](https://github.com/Bond-009)
  - [brianjmurrell](https://github.com/brianjmurrell)
  - [bugfixin](https://github.com/bugfixin)
  - [chaosinnovator](https://github.com/chaosinnovator)
@@ -31,6 +32,7 @@
  - [DaveChild](https://github.com/DaveChild)
  - [DavidFair](https://github.com/DavidFair)
  - [Delgan](https://github.com/Delgan)
+ - [DerMaddis](https://github.com/dermaddis)
  - [Derpipose](https://github.com/Derpipose)
  - [dcrdev](https://github.com/dcrdev)
  - [dhartung](https://github.com/dhartung)
@@ -54,6 +56,7 @@
  - [geilername](https://github.com/geilername)
  - [GermanCoding](https://github.com/GermanCoding)
  - [gnattu](https://github.com/gnattu)
+ - [gnuyent](https://github.com/gnuyent)
  - [GodTamIt](https://github.com/GodTamIt)
  - [grafixeyehero](https://github.com/grafixeyehero)
  - [h1nk](https://github.com/h1nk)
@@ -61,6 +64,7 @@
  - [HelloWorld017](https://github.com/HelloWorld017)
  - [ikomhoog](https://github.com/ikomhoog)
  - [iwalton3](https://github.com/iwalton3)
+ - [Jakob Kukla](https://github.com/jakobkukla)
  - [jftuga](https://github.com/jftuga)
  - [jkhsjdhjs](https://github.com/jkhsjdhjs)
  - [jmshrv](https://github.com/jmshrv)
@@ -69,8 +73,10 @@
  - [JustAMan](https://github.com/JustAMan)
  - [justinfenn](https://github.com/justinfenn)
  - [JPVenson](https://github.com/JPVenson)
+ - [JPUC1143](https://github.com/Jpuc1143/)
  - [KerryRJ](https://github.com/KerryRJ)
  - [Larvitar](https://github.com/Larvitar)
+ - [lbenini](https://github.com/lbenini)
  - [LeoVerto](https://github.com/LeoVerto)
  - [Liggy](https://github.com/Liggy)
  - [lmaonator](https://github.com/lmaonator)
@@ -83,15 +89,19 @@
  - [marius-luca-87](https://github.com/marius-luca-87)
  - [mark-monteiro](https://github.com/mark-monteiro)
  - [MarkCiliaVincenti](https://github.com/MarkCiliaVincenti)
+ - [Martin Reuter](https://github.com/reuterma24)
  - [Matt07211](https://github.com/Matt07211)
+ - [Matthew Jones](https://github.com/matthew-jones-uk)
  - [Maxr1998](https://github.com/Maxr1998)
  - [mcarlton00](https://github.com/mcarlton00)
+ - [Michael McElroy](https://github.com/mcmcelro)
  - [mitchfizz05](https://github.com/mitchfizz05)
  - [mohd-akram](https://github.com/mohd-akram)
  - [MrTimscampi](https://github.com/MrTimscampi)
  - [n8225](https://github.com/n8225)
  - [Nalsai](https://github.com/Nalsai)
  - [Narfinger](https://github.com/Narfinger)
+ - [Nathan McCrina](https://github.com/nfmccrina)
  - [NathanPickard](https://github.com/NathanPickard)
  - [neilsb](https://github.com/neilsb)
  - [nevado](https://github.com/nevado)
@@ -102,16 +112,19 @@
  - [OancaAndrei](https://github.com/OancaAndrei)
  - [obradovichv](https://github.com/obradovichv)
  - [oddstr13](https://github.com/oddstr13)
+ - [olsh](https://github.com/olsh)
  - [orryverducci](https://github.com/orryverducci)
  - [petermcneil](https://github.com/petermcneil)
  - [Phlogi](https://github.com/Phlogi)
  - [pjeanjean](https://github.com/pjeanjean)
  - [ploughpuff](https://github.com/ploughpuff)
+ - [poytiis](https://github.com/poytiis)
  - [pR0Ps](https://github.com/pR0Ps)
  - [PrplHaz4](https://github.com/PrplHaz4)
  - [RazeLighter777](https://github.com/RazeLighter777)
  - [redSpoutnik](https://github.com/redSpoutnik)
  - [ringmatter](https://github.com/ringmatter)
+ - [Robert Lützner](https://github.com/rluetzner)
  - [ryan-hartzell](https://github.com/ryan-hartzell)
  - [s0urcelab](https://github.com/s0urcelab)
  - [sachk](https://github.com/sachk)
@@ -127,6 +140,7 @@
  - [sl1288](https://github.com/sl1288)
  - [Smith00101010](https://github.com/Smith00101010)
  - [sorinyo2004](https://github.com/sorinyo2004)
+ - [Soumyadip Auddy](https://github.com/SoumyadipAuddy)
  - [sparky8251](https://github.com/sparky8251)
  - [spookbits](https://github.com/spookbits)
  - [ssenart](https://github.com/ssenart)
@@ -149,6 +163,7 @@
  - [twinkybot](https://github.com/twinkybot)
  - [Ullmie02](https://github.com/Ullmie02)
  - [Unhelpful](https://github.com/Unhelpful)
+ - [Utku Özdemir](https://github.com/utkuozdemir)
  - [viaregio](https://github.com/viaregio)
  - [vitorsemeano](https://github.com/vitorsemeano)
  - [voodoos](https://github.com/voodoos)
@@ -164,6 +179,7 @@
  - [XVicarious](https://github.com/XVicarious)
  - [YouKnowBlom](https://github.com/YouKnowBlom)
  - [ZachPhelan](https://github.com/ZachPhelan)
+ - [ZeusCraft10](https://github.com/ZeusCraft10)
  - [KristupasSavickas](https://github.com/KristupasSavickas)
  - [Pusta](https://github.com/pusta)
  - [nielsvanvelzen](https://github.com/nielsvanvelzen)
@@ -206,7 +222,15 @@
  - [theshoeshiner](https://github.com/theshoeshiner)
  - [TokerX](https://github.com/TokerX)
  - [GeneMarks](https://github.com/GeneMarks)
+ - [Kirill Nikiforov](https://github.com/allmazz)
+ - [bjorntp](https://github.com/bjorntp)
  - [martenumberto](https://github.com/martenumberto)
+ - [ZeusCraft10](https://github.com/ZeusCraft10)
+ - [MarcoCoreDuo](https://github.com/MarcoCoreDuo)
+ - [LiHRaM](https://github.com/LiHRaM)
+ - [MSalman5230](https://github.com/MSalman5230)
+ - [dwandw](https://github.com/dwandw)
+ - [Lampan-git](https://github.com/Lampan-git)
 
 # Emby Contributors
 
@@ -270,16 +294,3 @@
  - [tikuf](https://github.com/tikuf/)
  - [Tim Hobbs](https://github.com/timhobbs)
  - [SvenVandenbrande](https://github.com/SvenVandenbrande)
- - [olsh](https://github.com/olsh)
- - [lbenini](https://github.com/lbenini)
- - [gnuyent](https://github.com/gnuyent)
- - [Matthew Jones](https://github.com/matthew-jones-uk)
- - [Jakob Kukla](https://github.com/jakobkukla)
- - [Utku Özdemir](https://github.com/utkuozdemir)
- - [JPUC1143](https://github.com/Jpuc1143/)
- - [0x25CBFC4F](https://github.com/0x25CBFC4F)
- - [Robert Lützner](https://github.com/rluetzner)
- - [Nathan McCrina](https://github.com/nfmccrina)
- - [Martin Reuter](https://github.com/reuterma24)
- - [Michael McElroy](https://github.com/mcmcelro)
- - [Soumyadip Auddy](https://github.com/SoumyadipAuddy)

Directory.Packages.props

@@ -4,57 +4,52 @@
   </PropertyGroup>
   <!-- Run "dotnet list package (dash,dash)outdated" to see the latest versions of each package.-->
   <ItemGroup Label="Package Dependencies">
-    <PackageVersion Include="AsyncKeyedLock" Version="7.1.8" />
+    <PackageVersion Include="AsyncKeyedLock" Version="8.0.2" />
     <PackageVersion Include="AutoFixture.AutoMoq" Version="4.18.1" />
-    <PackageVersion Include="AutoFixture.Xunit2" Version="4.18.1" />
+    <PackageVersion Include="AutoFixture.Xunit3" Version="4.19.0" />
     <PackageVersion Include="AutoFixture" Version="4.18.1" />
     <PackageVersion Include="BDInfo" Version="0.8.0" />
-    <PackageVersion Include="BitFaster.Caching" Version="2.5.4" />
+    <PackageVersion Include="BitFaster.Caching" Version="2.6.0" />
     <PackageVersion Include="BlurHashSharp.SkiaSharp" Version="1.4.0-pre.1" />
     <PackageVersion Include="BlurHashSharp" Version="1.4.0-pre.1" />
     <PackageVersion Include="CommandLineParser" Version="2.9.1" />
-    <PackageVersion Include="coverlet.collector" Version="6.0.4" />
+    <PackageVersion Include="coverlet.collector" Version="10.0.0" />
-    <PackageVersion Include="Diacritics" Version="4.0.17" />
+    <PackageVersion Include="Diacritics" Version="4.1.8" />
     <PackageVersion Include="DiscUtils.Udf" Version="0.16.13" />
     <PackageVersion Include="DotNet.Glob" Version="3.1.3" />
-    <PackageVersion Include="FsCheck.Xunit" Version="3.3.2" />
+    <PackageVersion Include="FsCheck.Xunit.v3" Version="3.3.3" />
     <PackageVersion Include="HarfBuzzSharp.NativeAssets.Linux" Version="8.3.1.1" />
     <PackageVersion Include="ICU4N.Transliterator" Version="60.1.0-alpha.356" />
     <PackageVersion Include="IDisposableAnalyzers" Version="4.0.8" />
     <PackageVersion Include="Ignore" Version="0.2.1" />
-    <PackageVersion Include="Jellyfin.XmlTv" Version="10.8.0" />
+    <PackageVersion Include="Jellyfin.XmlTv" Version="10.12.0-pre1" />
     <PackageVersion Include="libse" Version="4.0.12" />
     <PackageVersion Include="LrcParser" Version="2025.623.0" />
-    <PackageVersion Include="MetaBrainz.MusicBrainz" Version="6.1.0" />
+    <PackageVersion Include="MetaBrainz.MusicBrainz" Version="8.0.1" />
-    <PackageVersion Include="Microsoft.AspNetCore.Authorization" Version="9.0.11" />
+    <PackageVersion Include="Microsoft.AspNetCore.Authorization" Version="10.0.8" />
-    <PackageVersion Include="Microsoft.AspNetCore.Mvc.Testing" Version="9.0.11" />
+    <PackageVersion Include="Microsoft.AspNetCore.Mvc.Testing" Version="10.0.8" />
     <PackageVersion Include="Microsoft.CodeAnalysis.BannedApiAnalyzers" Version="4.14.0" />
-    <PackageVersion Include="Microsoft.CodeAnalysis.Common" Version="4.14.0" />
+    <PackageVersion Include="Microsoft.CodeAnalysis.Common" Version="5.3.0" />
-    <PackageVersion Include="Microsoft.CodeAnalysis.CSharp" Version="4.14.0" />
+    <PackageVersion Include="Microsoft.CodeAnalysis.CSharp" Version="5.3.0" />
-    <PackageVersion Include="Microsoft.CodeAnalysis.Analyzers" Version="3.11.0" />
+    <PackageVersion Include="Microsoft.CodeAnalysis.Analyzers" Version="5.3.0" />
-    <PackageVersion Include="Microsoft.Data.Sqlite" Version="9.0.11" />
+    <PackageVersion Include="Microsoft.Data.Sqlite" Version="10.0.8" />
-    <PackageVersion Include="Microsoft.EntityFrameworkCore.Design" Version="9.0.11" />
+    <PackageVersion Include="Microsoft.EntityFrameworkCore.Design" Version="10.0.8" />
-    <PackageVersion Include="Microsoft.EntityFrameworkCore.Relational" Version="9.0.11" />
+    <PackageVersion Include="Microsoft.EntityFrameworkCore.Relational" Version="10.0.8" />
-    <PackageVersion Include="Microsoft.EntityFrameworkCore.Sqlite" Version="9.0.11" />
+    <PackageVersion Include="Microsoft.EntityFrameworkCore.Sqlite" Version="10.0.8" />
-    <PackageVersion Include="Microsoft.EntityFrameworkCore.Tools" Version="9.0.11" />
+    <PackageVersion Include="Microsoft.EntityFrameworkCore.Tools" Version="10.0.8" />
-    <PackageVersion Include="Microsoft.Extensions.Caching.Abstractions" Version="9.0.11" />
+    <PackageVersion Include="Microsoft.Extensions.Caching.Abstractions" Version="10.0.8" />
-    <PackageVersion Include="Microsoft.Extensions.Caching.Memory" Version="9.0.11" />
+    <PackageVersion Include="Microsoft.Extensions.Caching.Memory" Version="10.0.8" />
-    <PackageVersion Include="Microsoft.Extensions.Configuration.Abstractions" Version="9.0.11" />
+    <PackageVersion Include="Microsoft.Extensions.Configuration.Abstractions" Version="10.0.8" />
-    <PackageVersion Include="Microsoft.Extensions.Configuration.Binder" Version="9.0.11" />
+    <PackageVersion Include="Microsoft.Extensions.Configuration.Binder" Version="10.0.8" />
-    <PackageVersion Include="Microsoft.Extensions.Configuration.EnvironmentVariables" Version="9.0.11" />
+    <PackageVersion Include="Microsoft.Extensions.DependencyInjection" Version="10.0.8" />
-    <PackageVersion Include="Microsoft.Extensions.Configuration.Json" Version="9.0.11" />
+    <PackageVersion Include="Microsoft.Extensions.Diagnostics.HealthChecks.EntityFrameworkCore" Version="10.0.8" />
-    <PackageVersion Include="Microsoft.Extensions.DependencyInjection.Abstractions" Version="9.0.11" />
+    <PackageVersion Include="Microsoft.Extensions.Hosting.Abstractions" Version="10.0.8" />
-    <PackageVersion Include="Microsoft.Extensions.DependencyInjection" Version="9.0.11" />
+    <PackageVersion Include="Microsoft.Extensions.Http" Version="10.0.8" />
-    <PackageVersion Include="Microsoft.Extensions.Diagnostics.HealthChecks.EntityFrameworkCore" Version="9.0.11" />
+    <PackageVersion Include="Microsoft.Extensions.Logging" Version="10.0.8" />
-    <PackageVersion Include="Microsoft.Extensions.Diagnostics.HealthChecks" Version="9.0.11" />
+    <PackageVersion Include="Microsoft.Extensions.Options" Version="10.0.8" />
-    <PackageVersion Include="Microsoft.Extensions.Hosting.Abstractions" Version="9.0.11" />
+    <PackageVersion Include="Microsoft.NET.Test.Sdk" Version="18.5.1" />
-    <PackageVersion Include="Microsoft.Extensions.Http" Version="9.0.11" />
-    <PackageVersion Include="Microsoft.Extensions.Logging.Abstractions" Version="9.0.11" />
-    <PackageVersion Include="Microsoft.Extensions.Logging" Version="9.0.11" />
-    <PackageVersion Include="Microsoft.Extensions.Options" Version="9.0.11" />
-    <PackageVersion Include="Microsoft.NET.Test.Sdk" Version="18.0.1" />
     <PackageVersion Include="MimeTypes" Version="2.5.2" />
-    <PackageVersion Include="Morestachio" Version="5.0.1.631" />
+    <PackageVersion Include="Morestachio" Version="5.0.1.670" />
     <PackageVersion Include="Moq" Version="4.18.4" />
     <PackageVersion Include="NEbml" Version="1.1.0.5" />
     <PackageVersion Include="Newtonsoft.Json" Version="13.0.4" />
@@ -62,11 +57,11 @@
     <PackageVersion Include="prometheus-net.AspNetCore" Version="8.2.1" />
     <PackageVersion Include="prometheus-net.DotNetRuntime" Version="4.4.1" />
     <PackageVersion Include="prometheus-net" Version="8.2.1" />
-    <PackageVersion Include="Polly" Version="8.6.5" />
+    <PackageVersion Include="Polly" Version="8.6.6" />
-    <PackageVersion Include="Serilog.AspNetCore" Version="9.0.0" />
+    <PackageVersion Include="Serilog.AspNetCore" Version="10.0.0" />
     <PackageVersion Include="Serilog.Enrichers.Thread" Version="4.0.0" />
     <PackageVersion Include="Serilog.Expressions" Version="5.0.0" />
-    <PackageVersion Include="Serilog.Settings.Configuration" Version="9.0.0" />
+    <PackageVersion Include="Serilog.Settings.Configuration" Version="10.0.0" />
     <PackageVersion Include="Serilog.Sinks.Async" Version="2.1.0" />
     <PackageVersion Include="Serilog.Sinks.Console" Version="6.1.1" />
     <PackageVersion Include="Serilog.Sinks.File" Version="7.0.0" />
@@ -74,26 +69,21 @@
     <PackageVersion Include="SerilogAnalyzer" Version="0.15.0" />
     <PackageVersion Include="SharpFuzz" Version="2.2.0" />
     <!-- Pinned to 3.116.1 because https://github.com/jellyfin/jellyfin/pull/14255 -->
-    <PackageVersion Include="SkiaSharp" Version="3.116.1" />
+    <PackageVersion Include="SkiaSharp" Version="[3.116.1]" />
-    <PackageVersion Include="SkiaSharp.HarfBuzz" Version="3.116.1" />
+    <PackageVersion Include="SkiaSharp.HarfBuzz" Version="[3.116.1]" />
-    <PackageVersion Include="SkiaSharp.NativeAssets.Linux" Version="3.116.1" />
+    <PackageVersion Include="SkiaSharp.NativeAssets.Linux" Version="[3.116.1]" />
     <PackageVersion Include="SmartAnalyzers.MultithreadingAnalyzer" Version="1.1.31" />
     <PackageVersion Include="StyleCop.Analyzers" Version="1.2.0-beta.556" />
-    <PackageVersion Include="Svg.Skia" Version="3.2.1" />
+    <PackageVersion Include="Svg.Skia" Version="3.4.1" />
-    <PackageVersion Include="Swashbuckle.AspNetCore.ReDoc" Version="6.5.0" />
+    <PackageVersion Include="Swashbuckle.AspNetCore.ReDoc" Version="10.1.7" />
-    <PackageVersion Include="Swashbuckle.AspNetCore" Version="6.2.3" />
+    <PackageVersion Include="Swashbuckle.AspNetCore" Version="10.1.7" />
-    <PackageVersion Include="System.Globalization" Version="4.3.0" />
+    <PackageVersion Include="System.Text.Json" Version="10.0.8" />
-    <PackageVersion Include="System.Linq.Async" Version="6.0.3" />
-    <PackageVersion Include="System.Text.Encoding.CodePages" Version="9.0.11" />
-    <PackageVersion Include="System.Text.Json" Version="9.0.11" />
-    <PackageVersion Include="System.Threading.Tasks.Dataflow" Version="9.0.11" />
     <PackageVersion Include="TagLibSharp" Version="2.3.0" />
-    <PackageVersion Include="z440.atl.core" Version="7.9.0" />
+    <PackageVersion Include="z440.atl.core" Version="7.13.0" />
-    <PackageVersion Include="TMDbLib" Version="2.3.0" />
+    <PackageVersion Include="TMDbLib" Version="3.0.0" />
     <PackageVersion Include="UTF.Unknown" Version="2.6.0" />
-    <PackageVersion Include="Xunit.Priority" Version="1.1.6" />
+    <PackageVersion Include="xunit.runner.visualstudio" Version="3.1.5" />
-    <PackageVersion Include="xunit.runner.visualstudio" Version="2.8.2" />
+    <PackageVersion Include="xunit.v3" Version="3.2.2" />
-    <PackageVersion Include="Xunit.SkippableFact" Version="1.5.23" />
+    <PackageVersion Include="Xunit.v3.Priority" Version="1.1.18" />
-    <PackageVersion Include="xunit" Version="2.9.3" />
   </ItemGroup>
 </Project>

Emby.Naming/AudioBook/AudioBookNameParserResult.cs

@@ -1,3 +1,5 @@
+#pragma warning disable CA1815
+
 namespace Emby.Naming.AudioBook
 {
     /// <summary>

Emby.Naming/Book/BookFileNameParser.cs

@@ -0,0 +1,75 @@
+using System.Text.RegularExpressions;
+
+namespace Emby.Naming.Book
+{
+    /// <summary>
+    /// Helper class to retrieve basic metadata from a book filename.
+    /// </summary>
+    public static class BookFileNameParser
+    {
+        private const string NameMatchGroup = "name";
+        private const string IndexMatchGroup = "index";
+        private const string YearMatchGroup = "year";
+        private const string SeriesNameMatchGroup = "seriesName";
+
+        private static readonly Regex[] _nameMatches =
+        [
+            // seriesName (seriesYear) #index (of count) (year) where only seriesName and index are required
+            new Regex(@"^(?<seriesName>.+?)((\s\((?<seriesYear>[0-9]{4})\))?)\s#(?<index>[0-9]+)((\s\(of\s(?<count>[0-9]+)\))?)((\s\((?<year>[0-9]{4})\))?)$"),
+            new Regex(@"^(?<name>.+?)\s\((?<seriesName>.+?),\s#(?<index>[0-9]+)\)((\s\((?<year>[0-9]{4})\))?)$"),
+            new Regex(@"^(?<index>[0-9]+)\s\-\s(?<name>.+?)((\s\((?<year>[0-9]{4})\))?)$"),
+            new Regex(@"(?<name>.*)\((?<year>[0-9]{4})\)"),
+            // last resort matches the whole string as the name
+            new Regex(@"(?<name>.*)")
+        ];
+
+        /// <summary>
+        /// Parse a filename name to retrieve the book name, series name, index, and year.
+        /// </summary>
+        /// <param name="name">Book filename to parse for information.</param>
+        /// <returns>Returns <see cref="BookFileNameParserResult"/> object.</returns>
+        public static BookFileNameParserResult Parse(string? name)
+        {
+            var result = new BookFileNameParserResult();
+
+            if (name == null)
+            {
+                return result;
+            }
+
+            foreach (var regex in _nameMatches)
+            {
+                var match = regex.Match(name);
+
+                if (!match.Success)
+                {
+                    continue;
+                }
+
+                if (match.Groups.TryGetValue(NameMatchGroup, out Group? nameGroup) && nameGroup.Success)
+                {
+                    result.Name = nameGroup.Value.Trim();
+                }
+
+                if (match.Groups.TryGetValue(IndexMatchGroup, out Group? indexGroup) && indexGroup.Success && int.TryParse(indexGroup.Value, out var index))
+                {
+                    result.Index = index;
+                }
+
+                if (match.Groups.TryGetValue(YearMatchGroup, out Group? yearGroup) && yearGroup.Success && int.TryParse(yearGroup.Value, out var year))
+                {
+                    result.Year = year;
+                }
+
+                if (match.Groups.TryGetValue(SeriesNameMatchGroup, out Group? seriesGroup) && seriesGroup.Success)
+                {
+                    result.SeriesName = seriesGroup.Value.Trim();
+                }
+
+                break;
+            }
+
+            return result;
+        }
+    }
+}

Emby.Naming/Book/BookFileNameParserResult.cs

@@ -0,0 +1,41 @@
+using System;
+
+namespace Emby.Naming.Book
+{
+    /// <summary>
+    /// Data object used to pass metadata parsed from a book filename.
+    /// </summary>
+    public class BookFileNameParserResult
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="BookFileNameParserResult"/> class.
+        /// </summary>
+        public BookFileNameParserResult()
+        {
+            Name = null;
+            Index = null;
+            Year = null;
+            SeriesName = null;
+        }
+
+        /// <summary>
+        /// Gets or sets the name of the book.
+        /// </summary>
+        public string? Name { get; set; }
+
+        /// <summary>
+        /// Gets or sets the book index.
+        /// </summary>
+        public int? Index { get; set; }
+
+        /// <summary>
+        /// Gets or sets the publication year.
+        /// </summary>
+        public int? Year { get; set; }
+
+        /// <summary>
+        /// Gets or sets the series name.
+        /// </summary>
+        public string? SeriesName { get; set; }
+    }
+}

Emby.Naming/Common/NamingOptions.cs

@@ -152,8 +152,8 @@ namespace Emby.Naming.Common
 
             CleanStrings =
             [
-                @"^\s*(?<cleaned>.+?)[ _\,\.\(\)\[\]\-](3d|sbs|tab|hsbs|htab|mvc|HDR|HDC|UHD|UltraHD|4k|ac3|dts|custom|dc|divx|divx5|dsr|dsrip|dutch|dvd|dvdrip|dvdscr|dvdscreener|screener|dvdivx|cam|fragment|fs|hdtv|hdrip|hdtvrip|internal|limited|multi|subs|ntsc|ogg|ogm|pal|pdtv|proper|repack|rerip|retail|cd[1-9]|r5|bd5|bd|se|svcd|swedish|german|read.nfo|nfofix|unrated|ws|telesync|ts|telecine|tc|brrip|bdrip|480p|480i|576p|576i|720p|720i|1080p|1080i|2160p|hrhd|hrhdtv|hddvd|bluray|blu-ray|x264|x265|h264|h265|xvid|xvidvd|xxx|www.www|AAC|DTS|\[.*\])([ _\,\.\(\)\[\]\-]|$)",
+                @"^\s*(?<cleaned>.+?)[ _\,\.\(\)\[\]\-](3d|sbs|tab|hsbs|htab|mvc|HDR|HDC|UHD|UltraHD|4k|ac3|dts|custom|dc|divx|divx5|dsr|dsrip|dutch|dvd|dvdrip|dvdscr|dvdscreener|screener|dvdivx|cam|fragment|fs|hdtv|hdrip|hdtvrip|internal|limited|multi|subs|ntsc|ogg|ogm|pal|pdtv|proper|repack|rerip|retail|cd[1-9]|r5|bd5|bd|se|svcd|swedish|german|read.nfo|nfofix|unrated|ws|telesync|ts|telecine|tc|brrip|bdrip|480p|480i|576p|576i|720p|720i|1080p|1080i|2160p|hrhd|hrhdtv|hddvd|bluray|blu-ray|x264|x265|h264|h265|xvid|xvidvd|xxx|www.www|AAC|DTS)(?=[ _\,\.\(\)\[\]\-]|$)",
-                @"^(?<cleaned>.+?)(\[.*\])",
+                @"^\s*(?<cleaned>.+?)((\s*\[[^\]]+\]\s*)+)(\.[^\s]+)?$",
                 @"^\s*(?<cleaned>.+?)\WE[0-9]+(-|~)E?[0-9]+(\W|$)",
                 @"^\s*\[[^\]]+\](?!\.\w+$)\s*(?<cleaned>.+)",
                 @"^\s*(?<cleaned>.+?)\s+-\s+[0-9]+\s*$",
@@ -225,6 +225,7 @@ namespace Emby.Naming.Common
                 ".afc",
                 ".amf",
                 ".aif",
+                ".aifc",
                 ".aiff",
                 ".alac",
                 ".amr",
@@ -378,6 +379,14 @@ namespace Emby.Naming.Common
                     IsNamed = true
                 },
 
+                // "Name - 101.mkv", "Name - 101 [720p].mkv", "Name - 101 (2020).mkv"
+                // Handles absolute episode numbers with hyphen delimiter (common in anime)
+                // Without brackets (bracketed version handled above)
+                new EpisodeExpression(@".*[\\\/](?<seriesname>[^\\\/]+?)[\s_]+-[\s_]+(?<epnumber>[0-9]+)[\s_]*(?:\[.*?\]|\(.*?\))*[\s_]*(?:\.\w+)?$")
+                {
+                    IsNamed = true
+                },
+
                 // /server/anything_102.mp4
                 // /server/james.corden.2017.04.20.anne.hathaway.720p.hdtv.x264-crooks.mkv
                 // /server/anything_1996.11.14.mp4

Emby.Naming/Emby.Naming.csproj

@@ -6,7 +6,7 @@
   </PropertyGroup>
 
   <PropertyGroup>
-    <TargetFramework>net9.0</TargetFramework>
+    <TargetFramework>net10.0</TargetFramework>
     <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
     <GenerateDocumentationFile>true</GenerateDocumentationFile>
     <PublishRepositoryUrl>true</PublishRepositoryUrl>
@@ -36,7 +36,7 @@
   <PropertyGroup>
     <Authors>Jellyfin Contributors</Authors>
     <PackageId>Jellyfin.Naming</PackageId>
-    <VersionPrefix>10.11.4</VersionPrefix>
+    <VersionPrefix>12.0.0</VersionPrefix>
     <RepositoryUrl>https://github.com/jellyfin/jellyfin</RepositoryUrl>
     <PackageLicenseExpression>GPL-3.0-only</PackageLicenseExpression>
   </PropertyGroup>

Emby.Naming/TV/SeasonPathParser.cs

@@ -12,10 +12,10 @@ namespace Emby.Naming.TV
     {
         private static readonly Regex CleanNameRegex = new(@"[ ._\-\[\]]", RegexOptions.Compiled);
 
-        [GeneratedRegex(@"^\s*((?<seasonnumber>(?>\d+))(?:st|nd|rd|th|\.)*(?!\s*[Ee]\d+))\s*(?:[[시즌]*|[シーズン]*|[sS](?:eason|æson|aison|taffel|eries|tagione|äsong|eizoen|easong|ezon|ezona|ezóna|ezonul)*|[tT](?:emporada)*|[kK](?:ausi)*|[Сс](?:езон)*)\s*(?<rightpart>.*)$", RegexOptions.IgnoreCase)]
+        [GeneratedRegex(@"^\s*((?<seasonnumber>(?>\d+))(?:st|nd|rd|th|\.)*(?!\s*[Ee]\d+))\s*(?:[[시즌]*|[シーズン]*|[sS](?:eason|æson|aison|taffel|eries|tagione|äsong|eizoen|easong|ezon|ezona|ezóna|ezonul|érie|éria|erie|eria)*|[tT](?:emporada)*|[kK](?:ausi)*|[Сс](?:езон)*)\s*(?<rightpart>.*)$", RegexOptions.IgnoreCase)]
         private static partial Regex ProcessPre();
 
-        [GeneratedRegex(@"^\s*(?:[[시즌]*|[シーズン]*|[sS](?:eason|æson|aison|taffel|eries|tagione|äsong|eizoen|easong|ezon|ezona|ezóna|ezonul)*|[tT](?:emporada)*|[kK](?:ausi)*|[Сс](?:езон)*)\s*(?<seasonnumber>\d+?)(?=\d{3,4}p|[^\d]|$)(?!\s*[Ee]\d)(?<rightpart>.*)$", RegexOptions.IgnoreCase)]
+        [GeneratedRegex(@"^\s*(?:[[시즌]*|[シーズン]*|[sS](?:eason|æson|aison|taffel|eries|tagione|äsong|eizoen|easong|ezon|ezona|ezóna|ezonul|érie|éria|erie|eria)*|[tT](?:emporada)*|[kK](?:ausi)*|[Сс](?:езон)*)\s*(?<seasonnumber>\d+?)(?=\d{3,4}p|[^\d]|$)(?!\s*[Ee]\d)(?<rightpart>.*)$", RegexOptions.IgnoreCase)]
         private static partial Regex ProcessPost();
 
         [GeneratedRegex(@"[sS](\d{1,4})(?!\d|[eE]\d)(?=\.|_|-|\[|\]|\s|$)", RegexOptions.None)]

Emby.Naming/TV/SeriesResolver.cs

@@ -17,6 +17,13 @@ namespace Emby.Naming.TV
         [GeneratedRegex(@"((?<a>[^\._]{2,})[\._]*)|([\._](?<b>[^\._]{2,}))")]
         private static partial Regex SeriesNameRegex();
 
+        /// <summary>
+        /// Regex that matches titles with year in parentheses. Captures the title (which may be
+        /// numeric) before the year, i.e. turns "1923 (2022)" into "1923".
+        /// </summary>
+        [GeneratedRegex(@"(?<title>.+?)\s*\(\d{4}\)")]
+        private static partial Regex TitleWithYearRegex();
+
         /// <summary>
         /// Resolve information about series from path.
         /// </summary>
@@ -27,6 +34,20 @@ namespace Emby.Naming.TV
         {
             string seriesName = Path.GetFileName(path);
 
+            // First check if the filename matches a title with year pattern (handles numeric titles)
+            if (!string.IsNullOrEmpty(seriesName))
+            {
+                var titleWithYearMatch = TitleWithYearRegex().Match(seriesName);
+                if (titleWithYearMatch.Success)
+                {
+                    seriesName = titleWithYearMatch.Groups["title"].Value.Trim();
+                    return new SeriesInfo(path)
+                    {
+                        Name = seriesName
+                    };
+                }
+            }
+
             SeriesPathParserResult result = SeriesPathParser.Parse(options, path);
             if (result.Success)
             {

Emby.Naming/TV/TvParserHelpers.cs

@@ -18,7 +18,7 @@ public static class TvParserHelpers
     /// <param name="status">The status string.</param>
     /// <param name="enumValue">The <see cref="SeriesStatus"/>.</param>
     /// <returns>Returns true if parsing was successful.</returns>
-    public static bool TryParseSeriesStatus(string status, out SeriesStatus? enumValue)
+    public static bool TryParseSeriesStatus(string? status, out SeriesStatus? enumValue)
     {
         if (Enum.TryParse(status, true, out SeriesStatus seriesStatus))
         {

Emby.Naming/Video/CleanDateTimeResult.cs

@@ -1,3 +1,5 @@
+#pragma warning disable CA1815
+
 namespace Emby.Naming.Video
 {
     /// <summary>

Emby.Naming/Video/CleanStringParser.cs

@@ -44,7 +44,7 @@ namespace Emby.Naming.Video
             var match = expression.Match(name);
             if (match.Success && match.Groups.TryGetValue("cleaned", out var cleaned))
             {
-                newName = cleaned.Value;
+                newName = cleaned.Value.Trim();
                 return true;
             }
 

Emby.Naming/Video/VideoInfo.cs

@@ -17,8 +17,8 @@ namespace Emby.Naming.Video
         {
             Name = name;
 
-            Files = Array.Empty<VideoFileInfo>();
+            Files = [];
-            AlternateVersions = Array.Empty<VideoFileInfo>();
+            AlternateVersions = [];
         }
 
         /// <summary>
@@ -40,10 +40,10 @@ namespace Emby.Naming.Video
         public IReadOnlyList<VideoFileInfo> Files { get; set; }
 
         /// <summary>
-        /// Gets or sets the alternate versions.
+        /// Gets or sets the alternate versions. Each alternate may itself span multiple files.
         /// </summary>
         /// <value>The alternate versions.</value>
-        public IReadOnlyList<VideoFileInfo> AlternateVersions { get; set; }
+        public IReadOnlyList<VideoInfo> AlternateVersions { get; set; }
 
         /// <summary>
         /// Gets or sets the extra type.

Emby.Naming/Video/VideoListResolver.cs

@@ -1,10 +1,12 @@
 using System;
 using System.Collections.Generic;
+using System.Globalization;
 using System.IO;
 using System.Linq;
 using System.Text.RegularExpressions;
 using Emby.Naming.Common;
-using Jellyfin.Extensions;
+using Emby.Naming.TV;
+using Jellyfin.Data.Enums;
 using MediaBrowser.Model.IO;
 
 namespace Emby.Naming.Video
@@ -12,8 +14,23 @@ namespace Emby.Naming.Video
     /// <summary>
     /// Resolves alternative versions and extras from list of video files.
     /// </summary>
-    public static partial class VideoListResolver
+    public partial class VideoListResolver
     {
+        private static readonly StringComparer _numericOrdinalComparer = StringComparer.Create(CultureInfo.InvariantCulture, CompareOptions.NumericOrdering);
+
+        private readonly NamingOptions _namingOptions;
+        private readonly EpisodePathParser _episodePathParser;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="VideoListResolver"/> class.
+        /// </summary>
+        /// <param name="namingOptions">The naming options.</param>
+        public VideoListResolver(NamingOptions namingOptions)
+        {
+            _namingOptions = namingOptions;
+            _episodePathParser = new EpisodePathParser(namingOptions);
+        }
+
         [GeneratedRegex("[0-9]{2}[0-9]+[ip]", RegexOptions.IgnoreCase)]
         private static partial Regex ResolutionRegex();
 
@@ -24,12 +41,12 @@ namespace Emby.Naming.Video
         /// Resolves alternative versions and extras from list of video files.
         /// </summary>
         /// <param name="videoInfos">List of related video files.</param>
-        /// <param name="namingOptions">The naming options.</param>
         /// <param name="supportMultiVersion">Indication we should consider multi-versions of content.</param>
         /// <param name="parseName">Whether to parse the name or use the filename.</param>
         /// <param name="libraryRoot">Top-level folder for the containing library.</param>
+        /// <param name="collectionType">The type of the containing collection, if known.</param>
         /// <returns>Returns enumerable of <see cref="VideoInfo"/> which groups files together when related.</returns>
-        public static IReadOnlyList<VideoInfo> Resolve(IReadOnlyList<VideoFileInfo> videoInfos, NamingOptions namingOptions, bool supportMultiVersion = true, bool parseName = true, string? libraryRoot = "")
+        public IReadOnlyList<VideoInfo> Resolve(IReadOnlyList<VideoFileInfo> videoInfos, bool supportMultiVersion = true, bool parseName = true, string? libraryRoot = "", CollectionType? collectionType = null)
         {
             // Filter out all extras, otherwise they could cause stacks to not be resolved
             // See the unit test TestStackedWithTrailer
@@ -37,7 +54,7 @@ namespace Emby.Naming.Video
                 .Where(i => i.ExtraType is null)
                 .Select(i => new FileSystemMetadata { FullName = i.Path, IsDirectory = i.IsDirectory });
 
-            var stackResult = StackResolver.Resolve(nonExtras, namingOptions).ToList();
+            var stackResult = StackResolver.Resolve(nonExtras, _namingOptions).ToList();
 
             var remainingFiles = new List<VideoFileInfo>();
             var standaloneMedia = new List<VideoFileInfo>();
@@ -66,7 +83,7 @@ namespace Emby.Naming.Video
             {
                 var info = new VideoInfo(stack.Name)
                 {
-                    Files = stack.Files.Select(i => VideoResolver.Resolve(i, stack.IsDirectoryStack, namingOptions, parseName, libraryRoot))
+                    Files = stack.Files.Select(i => VideoResolver.Resolve(i, stack.IsDirectoryStack, _namingOptions, parseName, libraryRoot))
                         .OfType<VideoFileInfo>()
                         .ToList()
                 };
@@ -85,7 +102,9 @@ namespace Emby.Naming.Video
 
             if (supportMultiVersion)
             {
-                list = GetVideosGroupedByVersion(list, namingOptions);
+                list = collectionType is CollectionType.tvshows
+                    ? GetEpisodesGroupedByVersion(list)
+                    : GetVideosGroupedByVersion(list);
             }
 
             // Whatever files are left, just add them
@@ -99,7 +118,7 @@ namespace Emby.Naming.Video
             return list;
         }
 
-        private static List<VideoInfo> GetVideosGroupedByVersion(List<VideoInfo> videos, NamingOptions namingOptions)
+        private List<VideoInfo> GetVideosGroupedByVersion(List<VideoInfo> videos)
         {
             if (videos.Count == 0)
             {
@@ -123,7 +142,7 @@ namespace Emby.Naming.Video
                     continue;
                 }
 
-                if (!IsEligibleForMultiVersion(folderName, video.Files[0].FileNameWithoutExtension, namingOptions))
+                if (!IsEligibleForMultiVersion(folderName, video.Files[0].FileNameWithoutExtension))
                 {
                     return videos;
                 }
@@ -134,37 +153,9 @@ namespace Emby.Naming.Video
                 }
             }
 
-            if (videos.Count > 1)
+            var organized = OrganizeAlternateVersions(videos, primary, folderName.ToString());
-            {
-                var groups = videos.GroupBy(x => ResolutionRegex().IsMatch(x.Files[0].FileNameWithoutExtension)).ToList();
-                videos.Clear();
-                foreach (var group in groups)
-                {
-                    if (group.Key)
-                    {
-                        videos.InsertRange(0, group
-                            .OrderByDescending(x => ResolutionRegex().Match(x.Files[0].FileNameWithoutExtension.ToString()).Value, new AlphanumericComparator())
-                            .ThenBy(x => x.Files[0].FileNameWithoutExtension.ToString(), new AlphanumericComparator()));
-                    }
-                    else
-                    {
-                        videos.AddRange(group.OrderBy(x => x.Files[0].FileNameWithoutExtension.ToString(), new AlphanumericComparator()));
-                    }
-                }
-            }
 
-            primary ??= videos[0];
+            return [organized];
-            videos.Remove(primary);
-
-            var list = new List<VideoInfo>
-            {
-                primary
-            };
-
-            list[0].AlternateVersions = videos.Select(x => x.Files[0]).ToArray();
-            list[0].Name = folderName.ToString();
-
-            return list;
         }
 
         private static bool HaveSameYear(IReadOnlyList<VideoInfo> videos)
@@ -186,7 +177,7 @@ namespace Emby.Naming.Video
             return true;
         }
 
-        private static bool IsEligibleForMultiVersion(ReadOnlySpan<char> folderName, ReadOnlySpan<char> testFilename, NamingOptions namingOptions)
+        private bool IsEligibleForMultiVersion(ReadOnlySpan<char> folderName, ReadOnlySpan<char> testFilename)
         {
             if (!testFilename.StartsWith(folderName, StringComparison.OrdinalIgnoreCase))
             {
@@ -200,7 +191,7 @@ namespace Emby.Naming.Video
             }
 
             // There are no span overloads for regex unfortunately
-            if (CleanStringParser.TryClean(testFilename.ToString(), namingOptions.CleanStringRegexes, out var cleanName))
+            if (CleanStringParser.TryClean(testFilename.ToString(), _namingOptions.CleanStringRegexes, out var cleanName))
             {
                 testFilename = cleanName.AsSpan().Trim();
             }
@@ -208,7 +199,117 @@ namespace Emby.Naming.Video
             // The CleanStringParser should have removed common keywords etc.
             return testFilename.IsEmpty
                    || testFilename[0] == '-'
+                   || testFilename[0] == '_'
+                   || testFilename[0] == '.'
                    || CheckMultiVersionRegex().IsMatch(testFilename);
         }
+
+        private List<VideoInfo> GetEpisodesGroupedByVersion(List<VideoInfo> videos)
+        {
+            if (videos.Count < 2)
+            {
+                return videos;
+            }
+
+            var result = new List<VideoInfo>();
+            var groups = new Dictionary<string, List<VideoInfo>>(StringComparer.OrdinalIgnoreCase);
+
+            for (var i = 0; i < videos.Count; i++)
+            {
+                var video = videos[i];
+                var episodeResult = _episodePathParser.Parse(video.Files[0].Path, false);
+                string? key = null;
+                if (episodeResult.Success)
+                {
+                    if (episodeResult.IsByDate
+                        && episodeResult.Year.HasValue
+                        && episodeResult.Month.HasValue
+                        && episodeResult.Day.HasValue)
+                    {
+                        key = FormattableString.Invariant(
+                            $"D{episodeResult.Year.Value}{episodeResult.Month.Value:D2}{episodeResult.Day.Value:D2}");
+                    }
+                    else if (episodeResult.EpisodeNumber.HasValue)
+                    {
+                        key = FormattableString.Invariant(
+                            $"S{episodeResult.SeasonNumber ?? 0}E{episodeResult.EpisodeNumber.Value}");
+                    }
+                }
+
+                if (key is null)
+                {
+                    result.Add(video);
+                    continue;
+                }
+
+                if (!groups.TryGetValue(key, out var group))
+                {
+                    group = [];
+                    groups[key] = group;
+                }
+
+                group.Add(video);
+            }
+
+            foreach (var group in groups.Values)
+            {
+                if (group.Count == 1)
+                {
+                    result.Add(group[0]);
+                    continue;
+                }
+
+                result.Add(OrganizeAlternateVersions(group));
+            }
+
+            return result;
+        }
+
+        private static VideoInfo OrganizeAlternateVersions(
+            List<VideoInfo> videos,
+            VideoInfo? primaryOverride = null,
+            string? nameOverride = null)
+        {
+            if (videos.Count > 1)
+            {
+                var groups = videos
+                    .Select(x => (filename: x.Files[0].FileNameWithoutExtension.ToString(), value: x))
+                    .Select(x => (x.filename, resolutionMatch: ResolutionRegex().Match(x.filename), x.value))
+                    .GroupBy(x => x.resolutionMatch.Success)
+                    .ToList();
+
+                videos = [];
+
+                foreach (var group in groups)
+                {
+                    if (group.Key)
+                    {
+                        videos.InsertRange(0, group
+                            .OrderByDescending(x => x.resolutionMatch.Value, _numericOrdinalComparer)
+                            .ThenBy(x => x.filename, _numericOrdinalComparer)
+                            .Select(x => x.value));
+                    }
+                    else
+                    {
+                        videos.AddRange(group.OrderBy(x => x.filename, _numericOrdinalComparer).Select(x => x.value));
+                    }
+                }
+            }
+
+            // Prefer a stacked entry (more than one part) as primary
+            var primary = primaryOverride
+                ?? videos.FirstOrDefault(v => v.Files.Count > 1)
+                ?? videos[0];
+            videos.Remove(primary);
+
+            primary.AlternateVersions = videos;
+
+            if (nameOverride is not null)
+            {
+                primary.Name = nameOverride;
+            }
+
+            return primary;
+        }
     }
 }

Emby.Photos/Emby.Photos.csproj

@@ -19,7 +19,7 @@
   </ItemGroup>
 
   <PropertyGroup>
-    <TargetFramework>net9.0</TargetFramework>
+    <TargetFramework>net10.0</TargetFramework>
     <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
     <GenerateDocumentationFile>true</GenerateDocumentationFile>
   </PropertyGroup>

Emby.Server.Implementations/AppBase/BaseApplicationPaths.cs

@@ -90,6 +90,7 @@ namespace Emby.Server.Implementations.AppBase
             CreateAndCheckMarker(ProgramDataPath, "data");
             CreateAndCheckMarker(CachePath, "cache");
             CreateAndCheckMarker(DataPath, "data");
+            CreateCacheDirTag(CachePath);
         }
 
         /// <inheritdoc />
@@ -100,6 +101,26 @@ namespace Emby.Server.Implementations.AppBase
             CheckOrCreateMarker(path, $".jellyfin-{markerName}", recursive);
         }
 
+        /// <summary>
+        /// Creates a CACHEDIR.TAG file in the specified directory per the Cache Directory Tagging specification.
+        /// This signals to backup tools (e.g. Restic, Borg) that the directory contains cached data
+        /// and can be excluded from backups.
+        /// </summary>
+        /// <param name="path">The cache directory path.</param>
+        internal static void CreateCacheDirTag(string path)
+        {
+            var tagPath = Path.Combine(path, "CACHEDIR.TAG");
+            if (!File.Exists(tagPath))
+            {
+                File.WriteAllText(
+                    tagPath,
+                    "Signature: 8a477f597d28d172789f06886806bc55\n"
+                    + "# This file is a cache directory tag created by Jellyfin.\n"
+                    + "# For information about cache directory tags, see:\n"
+                    + "#\thttps://bford.info/cachedir/\n");
+            }
+        }
+
         private IEnumerable<string> GetMarkers(string path, bool recursive = false)
         {
             return Directory.EnumerateFiles(path, ".jellyfin-*", recursive ? SearchOption.AllDirectories : SearchOption.TopDirectoryOnly);

Emby.Server.Implementations/AppBase/BaseConfigurationManager.cs

@@ -228,6 +228,7 @@ namespace Emby.Server.Implementations.AppBase
             Logger.LogInformation("Setting cache path: {Path}", cachePath);
             ((BaseApplicationPaths)CommonApplicationPaths).CachePath = cachePath;
             CommonApplicationPaths.CreateAndCheckMarker(((BaseApplicationPaths)CommonApplicationPaths).CachePath, "cache");
+            BaseApplicationPaths.CreateCacheDirTag(cachePath);
         }
 
         /// <summary>

Emby.Server.Implementations/ApplicationHost.cs

@@ -14,6 +14,7 @@ using System.Reflection;
 using System.Security.Cryptography.X509Certificates;
 using System.Threading.Tasks;
 using Emby.Naming.Common;
+using Emby.Naming.Video;
 using Emby.Photos;
 using Emby.Server.Implementations.Chapters;
 using Emby.Server.Implementations.Collections;
@@ -25,6 +26,7 @@ using Emby.Server.Implementations.Dto;
 using Emby.Server.Implementations.HttpServer.Security;
 using Emby.Server.Implementations.IO;
 using Emby.Server.Implementations.Library;
+using Emby.Server.Implementations.Library.SimilarItems;
 using Emby.Server.Implementations.Localization;
 using Emby.Server.Implementations.Playlists;
 using Emby.Server.Implementations.Plugins;
@@ -92,7 +94,11 @@ using MediaBrowser.Model.System;
 using MediaBrowser.Model.Tasks;
 using MediaBrowser.Providers.Lyric;
 using MediaBrowser.Providers.Manager;
+using MediaBrowser.Providers.Plugins.ListenBrainz;
+using MediaBrowser.Providers.Plugins.ListenBrainz.Api;
 using MediaBrowser.Providers.Plugins.Tmdb;
+using MediaBrowser.Providers.Plugins.Tmdb.Movies;
+using MediaBrowser.Providers.Plugins.Tmdb.TV;
 using MediaBrowser.Providers.Subtitles;
 using MediaBrowser.XbmcMetadata.Providers;
 using Microsoft.AspNetCore.Http;
@@ -166,8 +172,6 @@ namespace Emby.Server.Implementations
                 ConfigurationManager.Configuration,
                 ApplicationPaths.PluginsPath,
                 ApplicationVersion);
-
-            _disposableParts.Add(_pluginManager);
         }
 
         /// <summary>
@@ -485,6 +489,11 @@ namespace Emby.Server.Implementations
             serviceCollection.AddScoped<ISystemManager, SystemManager>();
 
             serviceCollection.AddSingleton<TmdbClientManager>();
+            serviceCollection.AddSingleton<TmdbMovieSimilarProvider>();
+            serviceCollection.AddSingleton<TmdbSeriesSimilarProvider>();
+
+            serviceCollection.AddSingleton<ListenBrainzLabsClient>();
+            serviceCollection.AddSingleton<ListenBrainzSimilarArtistProvider>();
 
             serviceCollection.AddSingleton(NetManager);
 
@@ -507,7 +516,13 @@ namespace Emby.Server.Implementations
 
             serviceCollection.AddSingleton<IUserDataManager, UserDataManager>();
 
-            serviceCollection.AddSingleton<IItemRepository, BaseItemRepository>();
+            serviceCollection.AddSingleton<BaseItemRepository>();
+            serviceCollection.AddSingleton<IItemRepository>(sp => sp.GetRequiredService<BaseItemRepository>());
+            serviceCollection.AddSingleton<IItemQueryHelpers>(sp => sp.GetRequiredService<BaseItemRepository>());
+            serviceCollection.AddSingleton<IItemPersistenceService, ItemPersistenceService>();
+            serviceCollection.AddSingleton<INextUpService, NextUpService>();
+            serviceCollection.AddSingleton<IItemCountService, ItemCountService>();
+            serviceCollection.AddSingleton<ILinkedChildrenService, LinkedChildrenService>();
             serviceCollection.AddSingleton<IPeopleRepository, PeopleRepository>();
             serviceCollection.AddSingleton<IChapterRepository, ChapterRepository>();
             serviceCollection.AddSingleton<IMediaAttachmentRepository, MediaAttachmentRepository>();
@@ -526,10 +541,14 @@ namespace Emby.Server.Implementations
             serviceCollection.AddTransient(provider => new Lazy<IUserViewManager>(provider.GetRequiredService<IUserViewManager>));
             serviceCollection.AddSingleton<ILibraryManager, LibraryManager>();
             serviceCollection.AddSingleton<NamingOptions>();
+            serviceCollection.AddSingleton<VideoListResolver>();
 
             serviceCollection.AddSingleton<IMusicManager, MusicManager>();
 
             serviceCollection.AddSingleton<ILibraryMonitor, LibraryMonitor>();
+            serviceCollection.AddSingleton<DotIgnoreIgnoreRule>();
+
+            serviceCollection.AddSingleton<ISimilarItemsManager, SimilarItemsManager>();
 
             serviceCollection.AddSingleton<ISearchEngine, SearchEngine>();
 
@@ -641,6 +660,7 @@ namespace Emby.Server.Implementations
             BaseItem.ConfigurationManager = ConfigurationManager;
             BaseItem.FileSystem = Resolve<IFileSystem>();
             BaseItem.ItemRepository = Resolve<IItemRepository>();
+            BaseItem.ItemCountService = Resolve<IItemCountService>();
             BaseItem.LibraryManager = Resolve<ILibraryManager>();
             BaseItem.LocalizationManager = Resolve<ILocalizationManager>();
             BaseItem.Logger = Resolve<ILogger<BaseItem>>();
@@ -687,6 +707,8 @@ namespace Emby.Server.Implementations
                 GetExports<IExternalUrlProvider>());
 
             Resolve<IMediaSourceManager>().AddParts(GetExports<IMediaSourceProvider>());
+
+            Resolve<ISimilarItemsManager>().AddParts(GetExports<ISimilarItemsProvider>());
         }
 
         /// <summary>
@@ -1006,6 +1028,8 @@ namespace Emby.Server.Implementations
                 }
 
                 _disposableParts.Clear();
+
+                _pluginManager?.Dispose();
             }
 
             _disposed = true;

Emby.Server.Implementations/Chapters/ChapterManager.cs

@@ -7,6 +7,7 @@ using System.Threading.Tasks;
 using Jellyfin.Extensions;
 using MediaBrowser.Controller.Chapters;
 using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Entities.Audio;
 using MediaBrowser.Controller.IO;
 using MediaBrowser.Controller.Library;
 using MediaBrowser.Controller.MediaEncoding;
@@ -128,7 +129,7 @@ public class ChapterManager : IChapterManager
 
         var averageChapterDuration = GetAverageDurationBetweenChapters(chapters);
         var threshold = TimeSpan.FromSeconds(1).Ticks;
-        if (averageChapterDuration < threshold)
+        if (chapters.Count >= 2 && averageChapterDuration < threshold)
         {
             _logger.LogInformation("Skipping chapter image extraction for {Video} as the average chapter duration {AverageDuration} was lower than the minimum threshold {Threshold}", video.Name, averageChapterDuration, threshold);
             extractImages = false;
@@ -232,12 +233,22 @@ public class ChapterManager : IChapterManager
     }
 
     /// <inheritdoc />
-    public void SaveChapters(Video video, IReadOnlyList<ChapterInfo> chapters)
+    public bool Supports(BaseItem item)
+        => item is Video or Audio;
+
+    /// <inheritdoc />
+    public void SaveChapters(BaseItem item, IReadOnlyList<ChapterInfo> chapters)
     {
-        // Remove any chapters that are outside of the runtime of the video
+        if (!Supports(item))
-        var validChapters = chapters.Where(c => c.StartPositionTicks < video.RunTimeTicks).ToList();
+       {
-        _chapterRepository.SaveChapters(video.Id, validChapters);
+          _logger.LogWarning("Attempted to save chapters for unsupported item type {Type}: {Name} ({Id})", item.GetType().Name, item.Name, item.Id);
-    }
+          return;
+       }
+
+        // Remove any chapters that are outside of the runtime of the item
+        var validChapters = chapters.Where(c => c.StartPositionTicks < item.RunTimeTicks).ToList();
+        _chapterRepository.SaveChapters(item.Id, validChapters);
+}
 
     /// <inheritdoc />
     public ChapterInfo? GetChapter(Guid baseItemId, int index)

Emby.Server.Implementations/Collections/CollectionManager.cs

@@ -272,7 +272,7 @@ namespace Emby.Server.Implementations.Collections
             {
                 var childItem = _libraryManager.GetItemById(guidId);
 
-                var child = collection.LinkedChildren.FirstOrDefault(i => (i.ItemId.HasValue && i.ItemId.Value.Equals(guidId)) || (childItem is not null && string.Equals(childItem.Path, i.Path, StringComparison.OrdinalIgnoreCase)));
+                var child = collection.LinkedChildren.FirstOrDefault(i => i.ItemId.HasValue && i.ItemId.Value.Equals(guidId));
 
                 if (child is null)
                 {
@@ -342,7 +342,7 @@ namespace Emby.Server.Implementations.Collections
                     // this is kind of a performance hack because only Video has alternate versions that should be in a box set?
                     if (item is Video video)
                     {
-                        foreach (var childId in video.GetLocalAlternateVersionIds())
+                        foreach (var childId in _libraryManager.GetLocalAlternateVersionIds(video))
                         {
                             if (!results.ContainsKey(childId))
                             {

Emby.Server.Implementations/Cryptography/CryptographyProvider.cs

@@ -39,22 +39,24 @@ namespace Emby.Server.Implementations.Cryptography
         {
             if (string.Equals(hash.Id, "PBKDF2", StringComparison.Ordinal))
             {
+                var iterations = GetIterationsParameter(hash);
                 return hash.Hash.SequenceEqual(
                     Rfc2898DeriveBytes.Pbkdf2(
                         password,
                         hash.Salt,
-                        int.Parse(hash.Parameters["iterations"], CultureInfo.InvariantCulture),
+                        iterations,
                         HashAlgorithmName.SHA1,
                         32));
             }
 
             if (string.Equals(hash.Id, "PBKDF2-SHA512", StringComparison.Ordinal))
             {
+                var iterations = GetIterationsParameter(hash);
                 return hash.Hash.SequenceEqual(
                     Rfc2898DeriveBytes.Pbkdf2(
                         password,
                         hash.Salt,
-                        int.Parse(hash.Parameters["iterations"], CultureInfo.InvariantCulture),
+                        iterations,
                         HashAlgorithmName.SHA512,
                         DefaultOutputLength));
             }
@@ -62,6 +64,27 @@ namespace Emby.Server.Implementations.Cryptography
             throw new NotSupportedException($"Can't verify hash with id: {hash.Id}");
         }
 
+        /// <summary>
+        /// Extracts and validates the iterations parameter from a password hash.
+        /// </summary>
+        /// <param name="hash">The password hash containing parameters.</param>
+        /// <returns>The number of iterations.</returns>
+        /// <exception cref="FormatException">Thrown when iterations parameter is missing or invalid.</exception>
+        private static int GetIterationsParameter(PasswordHash hash)
+        {
+            if (!hash.Parameters.TryGetValue("iterations", out var iterationsStr))
+            {
+                throw new FormatException($"Password hash with id '{hash.Id}' is missing required 'iterations' parameter.");
+            }
+
+            if (!int.TryParse(iterationsStr, CultureInfo.InvariantCulture, out var iterations))
+            {
+                throw new FormatException($"Password hash with id '{hash.Id}' has invalid 'iterations' parameter: '{iterationsStr}'.");
+            }
+
+            return iterations;
+        }
+
         /// <inheritdoc />
         public byte[] GenerateSalt()
             => GenerateSalt(DefaultSaltLength);

Emby.Server.Implementations/Data/CleanDatabaseScheduledTask.cs

@@ -5,10 +5,12 @@ using System.IO;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
+using Jellyfin.Data.Enums;
 using Jellyfin.Database.Implementations;
 using MediaBrowser.Controller.Entities;
 using MediaBrowser.Controller.IO;
 using MediaBrowser.Controller.Library;
+using MediaBrowser.Controller.Playlists;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Logging;
 
@@ -35,7 +37,11 @@ public class CleanDatabaseScheduledTask : ILibraryPostScanTask
 
     public async Task Run(IProgress<double> progress, CancellationToken cancellationToken)
     {
-        await CleanDeadItems(cancellationToken, progress).ConfigureAwait(false);
+        var deadItemsProgress = new Progress<double>(val => progress.Report(val * 0.8));
+        await CleanDeadItems(cancellationToken, deadItemsProgress).ConfigureAwait(false);
+
+        var playlistProgress = new Progress<double>(val => progress.Report(80 + (val * 0.2)));
+        await CleanOrphanedFilePlaylistsAsync(cancellationToken, playlistProgress).ConfigureAwait(false);
     }
 
     private async Task CleanDeadItems(CancellationToken cancellationToken, IProgress<double> progress)
@@ -116,4 +122,32 @@ public class CleanDatabaseScheduledTask : ILibraryPostScanTask
 
         progress.Report(100);
     }
+
+    private async Task CleanOrphanedFilePlaylistsAsync(CancellationToken cancellationToken, IProgress<double> progress)
+    {
+        var playlists = _libraryManager.GetItemList(new InternalItemsQuery
+        {
+            IncludeItemTypes = [BaseItemKind.Playlist],
+            Recursive = true
+        }).OfType<Playlist>().ToList();
+
+        var numComplete = 0;
+        var numItems = Math.Max(playlists.Count, 1);
+
+        foreach (var playlist in playlists)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+
+            if (playlist.IsFile && !File.Exists(playlist.Path))
+            {
+                _logger.LogInformation("Removing file-based playlist {Name} because source file {Path} no longer exists", playlist.Name, playlist.Path);
+                _libraryManager.DeleteItem(playlist, new DeleteOptions { DeleteFileLocation = false });
+            }
+
+            numComplete++;
+            progress.Report((double)numComplete / numItems * 100);
+        }
+
+        progress.Report(100);
+    }
 }

Emby.Server.Implementations/Dto/DtoService.cs

@@ -153,17 +153,102 @@ namespace Emby.Server.Implementations.Dto
         private ILiveTvManager LivetvManager => _livetvManagerFactory.Value;
 
         /// <inheritdoc />
-        public IReadOnlyList<BaseItemDto> GetBaseItemDtos(IReadOnlyList<BaseItem> items, DtoOptions options, User? user = null, BaseItem? owner = null)
+        public IReadOnlyList<BaseItemDto> GetBaseItemDtos(
+            IReadOnlyList<BaseItem> items,
+            DtoOptions options,
+            User? user = null,
+            BaseItem? owner = null,
+            bool skipVisibilityCheck = false)
         {
-            var accessibleItems = user is null ? items : items.Where(x => x.IsVisible(user)).ToList();
+            var accessibleItems = skipVisibilityCheck || user is null ? items : items.Where(x => x.IsVisible(user)).ToList();
             var returnItems = new BaseItemDto[accessibleItems.Count];
             List<(BaseItem, BaseItemDto)>? programTuples = null;
             List<(BaseItemDto, LiveTvChannel)>? channelTuples = null;
 
+            // Batch-fetch user data for all items
+            Dictionary<Guid, UserItemData>? userDataBatch = null;
+            if (user is not null && options.EnableUserData)
+            {
+                userDataBatch = _userDataRepository.GetUserDataBatch(accessibleItems, user);
+            }
+
+            // Pre-compute collection folders once to avoid N+1 queries in CanDelete
+            List<Folder>? allCollectionFolders = null;
+            if (user is not null && options.ContainsField(ItemFields.CanDelete))
+            {
+                allCollectionFolders = _libraryManager.GetUserRootFolder().Children.OfType<Folder>().ToList();
+            }
+
+            // Batch-fetch child counts for all folders to avoid N+1 queries
+            Dictionary<Guid, int>? childCountBatch = null;
+            if (options.ContainsField(ItemFields.ChildCount))
+            {
+                var folderIds = accessibleItems.OfType<Folder>().Select(f => f.Id).ToList();
+                if (folderIds.Count > 0)
+                {
+                    childCountBatch = _libraryManager.GetChildCountBatch(folderIds, user?.Id);
+                }
+            }
+
+            // Batch-fetch played/total counts for all folders to avoid N+1 queries
+            Dictionary<Guid, (int Played, int Total)>? playedCountBatch = null;
+            if (user is not null && options.EnableUserData)
+            {
+                var folderIds = accessibleItems.OfType<Folder>()
+                    .Where(f => f.SupportsUserDataFromChildren && (f.SupportsPlayedStatus || options.ContainsField(ItemFields.RecursiveItemCount)))
+                    .Select(f => f.Id).ToList();
+                if (folderIds.Count > 0)
+                {
+                    playedCountBatch = _libraryManager.GetPlayedAndTotalCountBatch(folderIds, user);
+                }
+            }
+
+            // Batch-fetch MusicArtist lookups across all items to avoid N+1 queries.
+            IReadOnlyDictionary<string, MusicArtist[]>? artistsBatch = null;
+            var artistNames = new HashSet<string>(StringComparer.Ordinal);
+            foreach (var item in accessibleItems)
+            {
+                if (item is IHasArtist hasArtist)
+                {
+                    foreach (var name in hasArtist.Artists)
+                    {
+                        if (!string.IsNullOrWhiteSpace(name))
+                        {
+                            artistNames.Add(name);
+                        }
+                    }
+                }
+
+                if (item is IHasAlbumArtist hasAlbumArtist)
+                {
+                    foreach (var name in hasAlbumArtist.AlbumArtists)
+                    {
+                        if (!string.IsNullOrWhiteSpace(name))
+                        {
+                            artistNames.Add(name);
+                        }
+                    }
+                }
+            }
+
+            if (artistNames.Count > 0)
+            {
+                artistsBatch = _libraryManager.GetArtists(artistNames.ToArray());
+            }
+
             for (int index = 0; index < accessibleItems.Count; index++)
             {
                 var item = accessibleItems[index];
-                var dto = GetBaseItemDtoInternal(item, options, user, owner);
+                var dto = GetBaseItemDtoInternal(
+                    item,
+                    options,
+                    user,
+                    owner,
+                    userDataBatch?.GetValueOrDefault(item.Id),
+                    allCollectionFolders,
+                    childCountBatch,
+                    playedCountBatch,
+                    artistsBatch);
 
                 if (item is LiveTvChannel tvChannel)
                 {
@@ -197,7 +282,7 @@ namespace Emby.Server.Implementations.Dto
 
         public BaseItemDto GetBaseItemDto(BaseItem item, DtoOptions options, User? user = null, BaseItem? owner = null)
         {
-            var dto = GetBaseItemDtoInternal(item, options, user, owner);
+            var dto = GetBaseItemDtoInternal(item, options, user, owner, null);
             if (item is LiveTvChannel tvChannel)
             {
                 LivetvManager.AddChannelInfo(new[] { (dto, tvChannel) }, options, user);
@@ -215,7 +300,16 @@ namespace Emby.Server.Implementations.Dto
             return dto;
         }
 
-        private BaseItemDto GetBaseItemDtoInternal(BaseItem item, DtoOptions options, User? user = null, BaseItem? owner = null)
+        private BaseItemDto GetBaseItemDtoInternal(
+            BaseItem item,
+            DtoOptions options,
+            User? user = null,
+            BaseItem? owner = null,
+            UserItemData? userData = null,
+            List<Folder>? allCollectionFolders = null,
+            Dictionary<Guid, int>? childCountBatch = null,
+            Dictionary<Guid, (int Played, int Total)>? playedCountBatch = null,
+            IReadOnlyDictionary<string, MusicArtist[]>? artistsBatch = null)
         {
             var dto = new BaseItemDto
             {
@@ -252,7 +346,14 @@ namespace Emby.Server.Implementations.Dto
 
             if (user is not null)
             {
-                AttachUserSpecificInfo(dto, item, user, options);
+                AttachUserSpecificInfo(
+                    dto,
+                    item,
+                    user,
+                    options,
+                    userData,
+                    childCountBatch,
+                    playedCountBatch);
             }
 
             if (item is IHasMediaSources
@@ -268,13 +369,15 @@ namespace Emby.Server.Implementations.Dto
                 AttachStudios(dto, item);
             }
 
-            AttachBasicFields(dto, item, owner, options);
+            AttachBasicFields(dto, item, owner, options, artistsBatch);
 
             if (options.ContainsField(ItemFields.CanDelete))
             {
                 dto.CanDelete = user is null
                     ? item.CanDelete()
-                    : item.CanDelete(user);
+                    : allCollectionFolders is not null
+                        ? item.CanDelete(user, allCollectionFolders)
+                        : item.CanDelete(user);
             }
 
             if (options.ContainsField(ItemFields.CanDownload))
@@ -378,37 +481,7 @@ namespace Emby.Server.Implementations.Dto
                 return;
             }
 
-            var query = new InternalItemsQuery(user)
+            var counts = _libraryManager.GetItemCountsForNameItem(dto.Type, dto.Id, relatedItemKinds, user);
-            {
-                Recursive = true,
-                DtoOptions = new DtoOptions(false) { EnableImages = false },
-                IncludeItemTypes = relatedItemKinds
-            };
-
-            switch (dto.Type)
-            {
-                case BaseItemKind.Genre:
-                case BaseItemKind.MusicGenre:
-                    query.GenreIds = [dto.Id];
-                    break;
-                case BaseItemKind.MusicArtist:
-                    query.ArtistIds = [dto.Id];
-                    break;
-                case BaseItemKind.Person:
-                    query.PersonIds = [dto.Id];
-                    break;
-                case BaseItemKind.Studio:
-                    query.StudioIds = [dto.Id];
-                    break;
-                case BaseItemKind.Year
-                    when int.TryParse(dto.Name, NumberStyles.Integer, CultureInfo.InvariantCulture, out var year):
-                    query.Years = [year];
-                    break;
-                default:
-                    return;
-            }
-
-            var counts = _libraryManager.GetItemCounts(query);
 
             dto.AlbumCount = counts.AlbumCount;
             dto.ArtistCount = counts.ArtistCount;
@@ -458,7 +531,14 @@ namespace Emby.Server.Implementations.Dto
         /// <summary>
         /// Attaches the user specific info.
         /// </summary>
-        private void AttachUserSpecificInfo(BaseItemDto dto, BaseItem item, User user, DtoOptions options)
+        private void AttachUserSpecificInfo(
+            BaseItemDto dto,
+            BaseItem item,
+            User user,
+            DtoOptions options,
+            UserItemData? userData = null,
+            Dictionary<Guid, int>? childCountBatch = null,
+            Dictionary<Guid, (int Played, int Total)>? playedCountBatch = null)
         {
             if (item.IsFolder)
             {
@@ -466,7 +546,19 @@ namespace Emby.Server.Implementations.Dto
 
                 if (options.EnableUserData)
                 {
-                    dto.UserData = _userDataRepository.GetUserDataDto(item, dto, user, options);
+                    if (userData is not null)
+                    {
+                        // Use pre-fetched user data
+                        dto.UserData = GetUserItemDataDto(userData, item.Id);
+                        (int Played, int Total)? precomputed = playedCountBatch is not null
+                            && playedCountBatch.TryGetValue(item.Id, out var counts) ? counts : null;
+                        item.FillUserDataDtoValues(dto.UserData, userData, dto, user, options, precomputed);
+                    }
+                    else
+                    {
+                        // Fall back to individual fetch
+                        dto.UserData = _userDataRepository.GetUserDataDto(item, dto, user, options);
+                    }
                 }
 
                 if (!dto.ChildCount.HasValue && item.SourceType == SourceType.Library)
@@ -485,7 +577,7 @@ namespace Emby.Server.Implementations.Dto
 
                     if (options.ContainsField(ItemFields.ChildCount))
                     {
-                        dto.ChildCount ??= GetChildCount(folder, user);
+                        dto.ChildCount ??= GetChildCount(folder, user, childCountBatch);
                     }
                 }
 
@@ -503,7 +595,17 @@ namespace Emby.Server.Implementations.Dto
             {
                 if (options.EnableUserData)
                 {
-                    dto.UserData = _userDataRepository.GetUserDataDto(item, user);
+                    if (userData is not null)
+                    {
+                        // Use pre-fetched user data
+                        dto.UserData = GetUserItemDataDto(userData, item.Id);
+                        item.FillUserDataDtoValues(dto.UserData, userData, dto, user, options);
+                    }
+                    else
+                    {
+                        // Fall back to individual fetch
+                        dto.UserData = _userDataRepository.GetUserDataDto(item, user);
+                    }
                 }
             }
 
@@ -513,7 +615,25 @@ namespace Emby.Server.Implementations.Dto
             }
         }
 
-        private static int GetChildCount(Folder folder, User user)
+        private static UserItemDataDto GetUserItemDataDto(UserItemData data, Guid itemId)
+        {
+            ArgumentNullException.ThrowIfNull(data);
+
+            return new UserItemDataDto
+            {
+                IsFavorite = data.IsFavorite,
+                Likes = data.Likes,
+                PlaybackPositionTicks = data.PlaybackPositionTicks,
+                PlayCount = data.PlayCount,
+                Rating = data.Rating,
+                Played = data.Played,
+                LastPlayedDate = data.LastPlayedDate,
+                ItemId = itemId,
+                Key = data.Key
+            };
+        }
+
+        private static int GetChildCount(Folder folder, User user, Dictionary<Guid, int>? childCountBatch)
         {
             // Right now this is too slow to calculate for top level folders on a per-user basis
             // Just return something so that apps that are expecting a value won't think the folders are empty
@@ -522,6 +642,13 @@ namespace Emby.Server.Implementations.Dto
                 return Random.Shared.Next(1, 10);
             }
 
+            // Use pre-fetched batch data if available
+            if (childCountBatch is not null && childCountBatch.TryGetValue(folder.Id, out var count))
+            {
+                return count;
+            }
+
+            // Fall back to individual query for special cases (Series, Season, etc.)
             return folder.GetChildCount(user);
         }
 
@@ -815,7 +942,8 @@ namespace Emby.Server.Implementations.Dto
         /// <param name="item">The item.</param>
         /// <param name="owner">The owner.</param>
         /// <param name="options">The options.</param>
-        private void AttachBasicFields(BaseItemDto dto, BaseItem item, BaseItem? owner, DtoOptions options)
+        /// <param name="artistsBatch">Optional pre-fetched artist lookup shared across a batch of items.</param>
+        private void AttachBasicFields(BaseItemDto dto, BaseItem item, BaseItem? owner, DtoOptions options, IReadOnlyDictionary<string, MusicArtist[]>? artistsBatch = null)
         {
             if (options.ContainsField(ItemFields.DateCreated))
             {
@@ -939,6 +1067,8 @@ namespace Emby.Server.Implementations.Dto
                 dto.OriginalTitle = item.OriginalTitle;
             }
 
+            dto.OriginalLanguage = item.OriginalLanguage;
+
             if (options.ContainsField(ItemFields.ParentId))
             {
                 dto.ParentId = item.DisplayParentId;
@@ -1019,6 +1149,15 @@ namespace Emby.Server.Implementations.Dto
                 {
                     dto.AlbumId = albumParent.Id;
                     dto.AlbumPrimaryImageTag = GetTagAndFillBlurhash(dto, albumParent, ImageType.Primary);
+                    if (albumParent.LUFS.HasValue)
+                    {
+                        // -18 LUFS reference, same as ReplayGain 2.0, compatible with ReplayGain 1.0
+                        dto.AlbumNormalizationGain = -18f - albumParent.LUFS;
+                    }
+                    else if (albumParent.NormalizationGain.HasValue)
+                    {
+                        dto.AlbumNormalizationGain = albumParent.NormalizationGain;
+                    }
                 }
 
                 // if (options.ContainsField(ItemFields.MediaSourceCount))
@@ -1051,16 +1190,17 @@ namespace Emby.Server.Implementations.Dto
 
                 // Include artists that are not in the database yet, e.g., just added via metadata editor
                 // var foundArtists = artistItems.Items.Select(i => i.Item1.Name).ToList();
-                dto.ArtistItems = _libraryManager.GetArtists([.. hasArtist.Artists.Where(e => !string.IsNullOrWhiteSpace(e))])
+                var artistsLookup = artistsBatch
-                    .Where(e => e.Value.Length > 0)
+                    ?? _libraryManager.GetArtists([.. hasArtist.Artists.Where(e => !string.IsNullOrWhiteSpace(e))]);
-                    .Select(i =>
+
-                    {
+                dto.ArtistItems = hasArtist.Artists
-                        return new NameGuidPair
+                    .Where(name => !string.IsNullOrWhiteSpace(name))
-                        {
+                    .Distinct()
-                            Name = i.Key,
+                    .Select(name => artistsLookup.TryGetValue(name, out var artists) && artists.Length > 0
-                            Id = i.Value.First().Id
+                        ? new NameGuidPair { Name = name, Id = artists[0].Id }
-                        };
+                        : null)
-                    }).Where(i => i is not null).ToArray();
+                    .Where(item => item is not null)
+                    .ToArray();
             }
 
             if (item is IHasAlbumArtist hasAlbumArtist)
@@ -1085,31 +1225,17 @@ namespace Emby.Server.Implementations.Dto
                 //    })
                 //    .ToList();
 
+                var albumArtistsLookup = artistsBatch
+                    ?? _libraryManager.GetArtists([.. hasAlbumArtist.AlbumArtists.Where(e => !string.IsNullOrWhiteSpace(e))]);
+
                 dto.AlbumArtists = hasAlbumArtist.AlbumArtists
-                    // .Except(foundArtists, new DistinctNameComparer())
+                    .Where(name => !string.IsNullOrWhiteSpace(name))
-                    .Select(i =>
+                    .Distinct()
-                    {
+                    .Select(name => albumArtistsLookup.TryGetValue(name, out var albumArtists) && albumArtists.Length > 0
-                        // This should not be necessary but we're seeing some cases of it
+                        ? new NameGuidPair { Name = name, Id = albumArtists[0].Id }
-                        if (string.IsNullOrEmpty(i))
+                        : null)
-                        {
+                    .Where(item => item is not null)
-                            return null;
+                    .ToArray();
-                        }
-
-                        var artist = _libraryManager.GetArtist(i, new DtoOptions(false)
-                        {
-                            EnableImages = false
-                        });
-                        if (artist is not null)
-                        {
-                            return new NameGuidPair
-                            {
-                                Name = artist.Name,
-                                Id = artist.Id
-                            };
-                        }
-
-                        return null;
-                    }).Where(i => i is not null).ToArray();
             }
 
             // Add video info
@@ -1138,11 +1264,6 @@ namespace Emby.Server.Implementations.Dto
                     }
                 }
 
-                if (options.ContainsField(ItemFields.Chapters))
-                {
-                    dto.Chapters = _chapterManager.GetChapters(item.Id).ToList();
-                }
-
                 if (options.ContainsField(ItemFields.Trickplay))
                 {
                     var trickplay = _trickplayManager.GetTrickplayManifest(item).GetAwaiter().GetResult();
@@ -1156,6 +1277,11 @@ namespace Emby.Server.Implementations.Dto
                 dto.ExtraType = video.ExtraType;
             }
 
+            if (options.ContainsField(ItemFields.Chapters))
+            {
+                dto.Chapters = _chapterManager.GetChapters(item.Id).ToList();
+            }
+
             if (options.ContainsField(ItemFields.MediaStreams))
             {
                 // Add VideoInfo

Emby.Server.Implementations/Emby.Server.Implementations.csproj

@@ -27,7 +27,6 @@
     <PackageReference Include="Microsoft.Data.Sqlite" />
     <PackageReference Include="Microsoft.Extensions.DependencyInjection" />
     <PackageReference Include="Microsoft.Extensions.Caching.Memory" />
-    <PackageReference Include="Microsoft.Extensions.Configuration.Abstractions" />
     <PackageReference Include="Microsoft.Extensions.Hosting.Abstractions" />
     <PackageReference Include="Microsoft.EntityFrameworkCore.Relational" />
     <PackageReference Include="prometheus-net.DotNetRuntime" />
@@ -39,7 +38,7 @@
   </ItemGroup>
 
   <PropertyGroup>
-    <TargetFramework>net9.0</TargetFramework>
+    <TargetFramework>net10.0</TargetFramework>
     <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
     <GenerateDocumentationFile>true</GenerateDocumentationFile>
   </PropertyGroup>

Emby.Server.Implementations/HttpServer/WebSocketConnection.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Buffers;
+using System.Globalization;
 using System.IO.Pipelines;
 using System.Net;
 using System.Net.WebSockets;
@@ -69,6 +70,11 @@ namespace Emby.Server.Implementations.HttpServer
         /// <inheritdoc />
         public IPAddress? RemoteEndPoint { get; }
 
+        /// <summary>
+        /// Gets or initializes the UI culture captured from the upgrade request.
+        /// </summary>
+        public CultureInfo? RequestUICulture { get; init; }
+
         /// <inheritdoc />
         public Func<WebSocketMessageInfo, Task>? OnReceive { get; set; }
 
@@ -81,6 +87,17 @@ namespace Emby.Server.Implementations.HttpServer
         /// <inheritdoc />
         public WebSocketState State => _socket.State;
 
+        /// <inheritdoc />
+        public void ApplyRequestCulture()
+        {
+            if (RequestUICulture is null)
+            {
+                return;
+            }
+
+            CultureInfo.CurrentUICulture = RequestUICulture;
+        }
+
         /// <inheritdoc />
         public async Task SendAsync(OutboundWebSocketMessage message, CancellationToken cancellationToken)
         {

Emby.Server.Implementations/HttpServer/WebSocketManager.cs

@@ -4,6 +4,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Globalization;
 using System.Linq;
 using System.Net.WebSockets;
 using System.Threading.Tasks;
@@ -47,14 +48,18 @@ namespace Emby.Server.Implementations.HttpServer
                 _logger.LogInformation("WS {IP} request", context.Connection.RemoteIpAddress);
 
                 WebSocket webSocket = await context.WebSockets.AcceptWebSocketAsync().ConfigureAwait(false);
-
                 var connection = new WebSocketConnection(
                     _loggerFactory.CreateLogger<WebSocketConnection>(),
                     webSocket,
                     authorizationInfo,
                     context.GetNormalizedRemoteIP())
                 {
-                    OnReceive = ProcessWebSocketMessageReceived
+                    RequestUICulture = CultureInfo.CurrentUICulture
+                };
+                connection.OnReceive = result =>
+                {
+                    connection.ApplyRequestCulture();
+                    return ProcessWebSocketMessageReceived(result);
                 };
                 await using (connection.ConfigureAwait(false))
                 {

Emby.Server.Implementations/IO/LibraryMonitor.cs

@@ -21,6 +21,7 @@ namespace Emby.Server.Implementations.IO
         private readonly ILibraryManager _libraryManager;
         private readonly IServerConfigurationManager _configurationManager;
         private readonly IFileSystem _fileSystem;
+        private readonly DotIgnoreIgnoreRule _dotIgnoreIgnoreRule;
 
         /// <summary>
         /// The file system watchers.
@@ -47,19 +48,23 @@ namespace Emby.Server.Implementations.IO
         /// <param name="configurationManager">The configuration manager.</param>
         /// <param name="fileSystem">The filesystem.</param>
         /// <param name="appLifetime">The <see cref="IHostApplicationLifetime"/>.</param>
+        /// <param name="dotIgnoreIgnoreRule">The .ignore rule handler.</param>
         public LibraryMonitor(
             ILogger<LibraryMonitor> logger,
             ILibraryManager libraryManager,
             IServerConfigurationManager configurationManager,
             IFileSystem fileSystem,
-            IHostApplicationLifetime appLifetime)
+            IHostApplicationLifetime appLifetime,
+            DotIgnoreIgnoreRule dotIgnoreIgnoreRule)
         {
             _libraryManager = libraryManager;
             _logger = logger;
             _configurationManager = configurationManager;
             _fileSystem = fileSystem;
+            _dotIgnoreIgnoreRule = dotIgnoreIgnoreRule;
 
             appLifetime.ApplicationStarted.Register(Start);
+            appLifetime.ApplicationStopping.Register(Stop);
         }
 
         /// <inheritdoc />
@@ -352,6 +357,12 @@ namespace Emby.Server.Implementations.IO
                 return;
             }
 
+            var fileInfo = _fileSystem.GetFileSystemInfo(path);
+            if (_dotIgnoreIgnoreRule.ShouldIgnore(fileInfo, null))
+            {
+                return;
+            }
+
             // Ignore certain files, If the parent of an ignored path has a change event, ignore that too
             foreach (var i in _tempIgnoredPaths.Keys)
             {

Emby.Server.Implementations/IO/ManagedFileSystem.cs

@@ -586,6 +586,12 @@ namespace Emby.Server.Implementations.IO
         /// <inheritdoc />
         public virtual IEnumerable<FileSystemMetadata> GetFiles(string path, string searchPattern, IReadOnlyList<string>? extensions, bool enableCaseSensitiveExtensions, bool recursive = false)
         {
+            if (!Directory.Exists(path))
+            {
+                _logger.LogWarning("Directory does not exist: {Path}", path);
+                return [];
+            }
+
             var enumerationOptions = GetEnumerationOptions(recursive);
 
             // On linux and macOS the search pattern is case-sensitive

Emby.Server.Implementations/Images/BaseDynamicImageProvider.cs

@@ -267,22 +267,24 @@ namespace Emby.Server.Implementations.Images
         {
             var image = item.GetImageInfo(type, 0);
 
-            if (image is not null)
+            if (image is null)
             {
-                if (!image.IsLocalFile)
+                return GetItemsWithImages(item).Count is not 0;
-                {
+            }
-                    return false;
-                }
 
-                if (!FileSystem.ContainsSubPath(item.GetInternalMetadataPath(), image.Path))
+            if (!image.IsLocalFile)
-                {
+            {
-                    return false;
+                return false;
-                }
+            }
 
-                if (!HasChangedByDate(item, image))
+            if (!FileSystem.ContainsSubPath(item.GetInternalMetadataPath(), image.Path))
-                {
+            {
-                    return false;
+                return false;
-                }
+            }
+
+            if (!HasChangedByDate(item, image))
+            {
+                return false;
             }
 
             return true;

Emby.Server.Implementations/Images/CollectionFolderImageProvider.cs

@@ -40,7 +40,7 @@ namespace Emby.Server.Implementations.Images
                     includeItemTypes = new[] { BaseItemKind.Series };
                     break;
                 case CollectionType.music:
-                    includeItemTypes = new[] { BaseItemKind.MusicAlbum };
+                    includeItemTypes = new[] { BaseItemKind.MusicArtist };  // Music albums usually don't have dedicated backdrops, so use artist instead
                     break;
                 case CollectionType.musicvideos:
                     includeItemTypes = new[] { BaseItemKind.MusicVideo };
@@ -98,5 +98,11 @@ namespace Emby.Server.Implementations.Images
 
             return base.CreateImage(item, itemsWithImages, outputPath, imageType, imageIndex);
         }
+
+        protected override bool HasChangedByDate(BaseItem item, ItemImageInfo image)
+        {
+            var age = DateTime.UtcNow - image.DateModified;
+            return age.TotalDays > 7;
+        }
     }
 }

Emby.Server.Implementations/Library/DotIgnoreIgnoreRule.cs

@@ -1,6 +1,8 @@
 using System;
+using System.Collections.Generic;
 using System.IO;
 using System.Text.RegularExpressions;
+using BitFaster.Caching.Lru;
 using MediaBrowser.Controller.Entities;
 using MediaBrowser.Controller.IO;
 using MediaBrowser.Controller.Resolvers;
@@ -15,22 +17,36 @@ public class DotIgnoreIgnoreRule : IResolverIgnoreRule
 {
     private static readonly bool IsWindows = OperatingSystem.IsWindows();
 
-    private static FileInfo? FindIgnoreFile(DirectoryInfo directory)
+    private readonly FastConcurrentLru<string, IgnoreFileCacheEntry> _directoryCache;
-    {
+    private readonly FastConcurrentLru<string, ParsedIgnoreCacheEntry> _rulesCache;
-        for (var current = directory; current is not null; current = current.Parent)
-        {
-            var ignorePath = Path.Join(current.FullName, ".ignore");
-            if (File.Exists(ignorePath))
-            {
-                return new FileInfo(ignorePath);
-            }
-        }
 
-        return null;
+    /// <summary>
+    /// Initializes a new instance of the <see cref="DotIgnoreIgnoreRule"/> class.
+    /// </summary>
+    public DotIgnoreIgnoreRule()
+    {
+        var cacheSize = Math.Max(100, Environment.ProcessorCount * 100);
+        _directoryCache = new FastConcurrentLru<string, IgnoreFileCacheEntry>(
+            Environment.ProcessorCount,
+            cacheSize,
+            StringComparer.Ordinal);
+        _rulesCache = new FastConcurrentLru<string, ParsedIgnoreCacheEntry>(
+            Environment.ProcessorCount,
+            Math.Max(32, cacheSize / 4),
+            StringComparer.Ordinal);
     }
 
     /// <inheritdoc />
-    public bool ShouldIgnore(FileSystemMetadata fileInfo, BaseItem? parent) => IsIgnored(fileInfo, parent);
+    public bool ShouldIgnore(FileSystemMetadata fileInfo, BaseItem? parent) => IsIgnoredInternal(fileInfo, parent);
+
+    /// <summary>
+    /// Clears the directory lookup cache. The parsed rules cache is not cleared
+    /// as it validates file modification time on each access.
+    /// </summary>
+    public void ClearDirectoryCache()
+    {
+        _directoryCache.Clear();
+    }
 
     /// <summary>
     /// Checks whether or not the file is ignored.
@@ -38,40 +54,38 @@ public class DotIgnoreIgnoreRule : IResolverIgnoreRule
     /// <param name="fileInfo">The file information.</param>
     /// <param name="parent">The parent BaseItem.</param>
     /// <returns>True if the file should be ignored.</returns>
-    public static bool IsIgnored(FileSystemMetadata fileInfo, BaseItem? parent)
+    public bool IsIgnoredInternal(FileSystemMetadata fileInfo, BaseItem? parent)
     {
         var searchDirectory = fileInfo.IsDirectory
-            ? new DirectoryInfo(fileInfo.FullName)
+            ? fileInfo.FullName
-            : new DirectoryInfo(Path.GetDirectoryName(fileInfo.FullName) ?? string.Empty);
+            : Path.GetDirectoryName(fileInfo.FullName);
 
-        if (string.IsNullOrEmpty(searchDirectory.FullName))
+        if (string.IsNullOrEmpty(searchDirectory))
         {
             return false;
         }
 
-        var ignoreFile = FindIgnoreFile(searchDirectory);
+        var ignoreFile = FindIgnoreFileCached(searchDirectory);
         if (ignoreFile is null)
         {
             return false;
         }
 
-        // Fast path in case the ignore files isn't a symlink and is empty
+        var parsedEntry = GetParsedRules(ignoreFile);
-        if (ignoreFile.LinkTarget is null && ignoreFile.Length == 0)
+        if (parsedEntry is null)
+        {
+            // File was deleted after we cached the path - clear the directory cache entry and return false
+            _directoryCache.TryRemove(searchDirectory, out _);
+            return false;
+        }
+
+        // Empty file means ignore everything
+        if (parsedEntry.IsEmpty)
         {
-            // Ignore directory if we just have the file
             return true;
         }
 
-        var content = GetFileContent(ignoreFile);
+        return parsedEntry.Rules.IsIgnored(GetPathToCheck(fileInfo.FullName, fileInfo.IsDirectory));
-        return string.IsNullOrWhiteSpace(content)
-            || CheckIgnoreRules(fileInfo.FullName, content, fileInfo.IsDirectory);
-    }
-
-    private static bool CheckIgnoreRules(string path, string ignoreFileContent, bool isDirectory)
-    {
-        // If file has content, base ignoring off the content .gitignore-style rules
-        var rules = ignoreFileContent.Split('\n', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
-        return CheckIgnoreRules(path, rules, isDirectory);
     }
 
     /// <summary>
@@ -117,8 +131,8 @@ public class DotIgnoreIgnoreRule : IResolverIgnoreRule
             return true;
         }
 
-         // Mitigate the problem of the Ignore library not handling Windows paths correctly.
+        // Mitigate the problem of the Ignore library not handling Windows paths correctly.
-         // See https://github.com/jellyfin/jellyfin/issues/15484
+        // See https://github.com/jellyfin/jellyfin/issues/15484
         var pathToCheck = normalizePath ? path.NormalizePath('/') : path;
 
         // Add trailing slash for directories to match "folder/"
@@ -130,11 +144,196 @@ public class DotIgnoreIgnoreRule : IResolverIgnoreRule
         return ignore.IsIgnored(pathToCheck);
     }
 
-    private static string GetFileContent(FileInfo ignoreFile)
+    private FileInfo? FindIgnoreFileCached(string directory)
     {
-        ignoreFile = FileSystemHelper.ResolveLinkTarget(ignoreFile, returnFinalTarget: true) ?? ignoreFile;
+        // Check if we have a cached result for this directory
-        return ignoreFile.Exists
+        if (_directoryCache.TryGet(directory, out var cached))
-            ? File.ReadAllText(ignoreFile.FullName)
+        {
-            : string.Empty;
+            return cached.IgnoreFileDirectory is null
+                ? null
+                : new FileInfo(Path.Join(cached.IgnoreFileDirectory, ".ignore"));
+        }
+
+        DirectoryInfo startDir;
+        try
+        {
+            startDir = new DirectoryInfo(directory);
+        }
+        catch (ArgumentException)
+        {
+            return null;
+        }
+
+        // Walk up the directory tree to find .ignore file using DirectoryInfo.Parent
+        var checkedDirs = new List<string> { directory };
+
+        for (var current = startDir; current is not null; current = current.Parent)
+        {
+            var currentPath = current.FullName;
+
+            // Check if this intermediate directory is cached
+            if (current != startDir && _directoryCache.TryGet(currentPath, out var parentCached))
+            {
+                // Cache the result for all directories we checked
+                var entry = new IgnoreFileCacheEntry(parentCached.IgnoreFileDirectory);
+                foreach (var dir in checkedDirs)
+                {
+                    _directoryCache.AddOrUpdate(dir, entry);
+                }
+
+                return parentCached.IgnoreFileDirectory is null
+                    ? null
+                    : new FileInfo(Path.Join(parentCached.IgnoreFileDirectory, ".ignore"));
+            }
+
+            var ignoreFile = new FileInfo(Path.Join(currentPath, ".ignore"));
+            if (ignoreFile.Exists)
+            {
+                // Cache for all directories we checked
+                var entry = new IgnoreFileCacheEntry(currentPath);
+                foreach (var dir in checkedDirs)
+                {
+                    _directoryCache.AddOrUpdate(dir, entry);
+                }
+
+                return ignoreFile;
+            }
+
+            if (current != startDir)
+            {
+                checkedDirs.Add(currentPath);
+            }
+        }
+
+        // No .ignore file found - cache null result for all directories
+        var nullEntry = new IgnoreFileCacheEntry((string?)null);
+        foreach (var dir in checkedDirs)
+        {
+            _directoryCache.AddOrUpdate(dir, nullEntry);
+        }
+
+        return null;
+    }
+
+    private ParsedIgnoreCacheEntry? GetParsedRules(FileInfo ignoreFile)
+    {
+        if (!ignoreFile.Exists)
+        {
+            _rulesCache.TryRemove(ignoreFile.FullName, out _);
+            return null;
+        }
+
+        var lastModified = ignoreFile.LastWriteTimeUtc;
+        var fileLength = ignoreFile.Length;
+        var key = ignoreFile.FullName;
+
+        // Check cache
+        if (_rulesCache.TryGet(key, out var cached))
+        {
+            if (cached.FileLastModified == lastModified && cached.FileLength == fileLength)
+            {
+                return cached;
+            }
+
+            // Stale - need to reparse
+            _rulesCache.TryRemove(key, out _);
+        }
+
+        // Parse the file
+        var parsedEntry = ParseIgnoreFile(ignoreFile, lastModified, fileLength);
+        _rulesCache.AddOrUpdate(key, parsedEntry);
+        return parsedEntry;
+    }
+
+    private static ParsedIgnoreCacheEntry ParseIgnoreFile(FileInfo ignoreFile, DateTime lastModified, long fileLength)
+    {
+        if (ignoreFile.LinkTarget is null && fileLength == 0)
+        {
+            return new ParsedIgnoreCacheEntry
+            {
+                Rules = new Ignore.Ignore(),
+                FileLastModified = lastModified,
+                FileLength = fileLength,
+                IsEmpty = true
+            };
+        }
+
+        // Resolve symlinks
+        var resolvedFile = FileSystemHelper.ResolveLinkTarget(ignoreFile, returnFinalTarget: true) ?? ignoreFile;
+        if (!resolvedFile.Exists)
+        {
+            return new ParsedIgnoreCacheEntry
+            {
+                Rules = new Ignore.Ignore(),
+                FileLastModified = lastModified,
+                FileLength = fileLength,
+                IsEmpty = true
+            };
+        }
+
+        var content = File.ReadAllText(resolvedFile.FullName);
+        if (string.IsNullOrWhiteSpace(content))
+        {
+            return new ParsedIgnoreCacheEntry
+            {
+                Rules = new Ignore.Ignore(),
+                FileLastModified = lastModified,
+                FileLength = fileLength,
+                IsEmpty = true
+            };
+        }
+
+        var rules = content.Split('\n', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
+        var ignore = new Ignore.Ignore();
+        var validRulesAdded = 0;
+
+        foreach (var rule in rules)
+        {
+            try
+            {
+                ignore.Add(rule);
+                validRulesAdded++;
+            }
+            catch (RegexParseException)
+            {
+                // Ignore invalid patterns
+            }
+        }
+
+        // No valid rules means treat as empty (ignore all)
+        return new ParsedIgnoreCacheEntry
+        {
+            Rules = ignore,
+            FileLastModified = lastModified,
+            FileLength = fileLength,
+            IsEmpty = validRulesAdded == 0
+        };
+    }
+
+    private static string GetPathToCheck(string path, bool isDirectory)
+    {
+        // Normalize Windows paths
+        var pathToCheck = IsWindows ? path.NormalizePath('/') : path;
+
+        // Add trailing slash for directories to match "folder/"
+        if (isDirectory)
+        {
+            pathToCheck = string.Concat(pathToCheck.AsSpan().TrimEnd('/'), "/");
+        }
+
+        return pathToCheck;
+    }
+
+    private readonly record struct IgnoreFileCacheEntry(string? IgnoreFileDirectory);
+
+    private sealed class ParsedIgnoreCacheEntry
+    {
+        public required Ignore.Ignore Rules { get; init; }
+
+        public required DateTime FileLastModified { get; init; }
+
+        public required long FileLength { get; init; }
+
+        public required bool IsEmpty { get; init; }
     }
 }

Emby.Server.Implementations/Library/IgnorePatterns.cs

@@ -31,6 +31,20 @@ namespace Emby.Server.Implementations.Library
             "**/*.sample.?????",
             "**/sample/*",
 
+            // Avoid adding Hungarian sample files
+            // https://github.com/jellyfin/jellyfin/issues/16237
+            "**/minta.?",
+            "**/minta.??",
+            "**/minta.???", // Matches minta.mkv
+            "**/minta.????", // Matches minta.webm
+            "**/minta.?????",
+            "**/*.minta.?",
+            "**/*.minta.??",
+            "**/*.minta.???",
+            "**/*.minta.????",
+            "**/*.minta.?????",
+            "**/minta/*",
+
             // Directories
             "**/metadata/**",
             "**/metadata",
@@ -50,6 +64,10 @@ namespace Emby.Server.Implementations.Library
             "**/lost+found",
             "**/subs/**",
             "**/subs",
+            "**/.snapshots/**",
+            "**/.snapshots",
+            "**/.snapshot/**",
+            "**/.snapshot",
 
             // Trickplay files
             "**/*.trickplay",

Emby.Server.Implementations/Library/LibraryManager.cs

@@ -13,6 +13,7 @@ using System.Threading.Tasks;
 using BitFaster.Caching.Lru;
 using Emby.Naming.Common;
 using Emby.Naming.TV;
+using Emby.Naming.Video;
 using Emby.Server.Implementations.Library.Resolvers;
 using Emby.Server.Implementations.Library.Validators;
 using Emby.Server.Implementations.Playlists;
@@ -30,18 +31,17 @@ using MediaBrowser.Controller.Drawing;
 using MediaBrowser.Controller.Dto;
 using MediaBrowser.Controller.Entities;
 using MediaBrowser.Controller.Entities.Audio;
+using MediaBrowser.Controller.Entities.Movies;
 using MediaBrowser.Controller.IO;
 using MediaBrowser.Controller.Library;
 using MediaBrowser.Controller.LiveTv;
 using MediaBrowser.Controller.MediaEncoding;
-using MediaBrowser.Controller.MediaSegments;
 using MediaBrowser.Controller.Persistence;
+using MediaBrowser.Controller.Playlists;
 using MediaBrowser.Controller.Providers;
 using MediaBrowser.Controller.Resolvers;
 using MediaBrowser.Controller.Sorting;
-using MediaBrowser.Controller.Trickplay;
 using MediaBrowser.Model.Configuration;
-using MediaBrowser.Model.Dlna;
 using MediaBrowser.Model.Drawing;
 using MediaBrowser.Model.Dto;
 using MediaBrowser.Model.Entities;
@@ -77,12 +77,18 @@ namespace Emby.Server.Implementations.Library
         private readonly IMediaEncoder _mediaEncoder;
         private readonly IFileSystem _fileSystem;
         private readonly IItemRepository _itemRepository;
+        private readonly IItemPersistenceService _persistenceService;
+        private readonly INextUpService _nextUpService;
+        private readonly IItemCountService _countService;
+        private readonly ILinkedChildrenService _linkedChildrenService;
         private readonly IImageProcessor _imageProcessor;
         private readonly NamingOptions _namingOptions;
         private readonly IPeopleRepository _peopleRepository;
         private readonly ExtraResolver _extraResolver;
         private readonly IPathManager _pathManager;
         private readonly FastConcurrentLru<Guid, BaseItem> _cache;
+        private readonly DotIgnoreIgnoreRule _dotIgnoreIgnoreRule;
+        private readonly IMediaStreamRepository _mediaStreamRepository;
 
         /// <summary>
         /// The _root folder sync lock.
@@ -115,11 +121,17 @@ namespace Emby.Server.Implementations.Library
         /// <param name="userViewManagerFactory">The user view manager.</param>
         /// <param name="mediaEncoder">The media encoder.</param>
         /// <param name="itemRepository">The item repository.</param>
+        /// <param name="persistenceService">The item persistence service.</param>
+        /// <param name="nextUpService">The next up service.</param>
+        /// <param name="countService">The item count service.</param>
+        /// <param name="linkedChildrenService">The linked children service.</param>
         /// <param name="imageProcessor">The image processor.</param>
         /// <param name="namingOptions">The naming options.</param>
         /// <param name="directoryService">The directory service.</param>
         /// <param name="peopleRepository">The people repository.</param>
         /// <param name="pathManager">The path manager.</param>
+        /// <param name="dotIgnoreIgnoreRule">The .ignore rule handler.</param>
+        /// <param name="mediaStreamRepository">The media stream repository.</param>
         public LibraryManager(
             IServerApplicationHost appHost,
             ILoggerFactory loggerFactory,
@@ -133,11 +145,17 @@ namespace Emby.Server.Implementations.Library
             Lazy<IUserViewManager> userViewManagerFactory,
             IMediaEncoder mediaEncoder,
             IItemRepository itemRepository,
+            IItemPersistenceService persistenceService,
+            INextUpService nextUpService,
+            IItemCountService countService,
+            ILinkedChildrenService linkedChildrenService,
             IImageProcessor imageProcessor,
             NamingOptions namingOptions,
             IDirectoryService directoryService,
             IPeopleRepository peopleRepository,
-            IPathManager pathManager)
+            IPathManager pathManager,
+            DotIgnoreIgnoreRule dotIgnoreIgnoreRule,
+            IMediaStreamRepository mediaStreamRepository)
         {
             _appHost = appHost;
             _logger = loggerFactory.CreateLogger<LibraryManager>();
@@ -151,6 +169,10 @@ namespace Emby.Server.Implementations.Library
             _userViewManagerFactory = userViewManagerFactory;
             _mediaEncoder = mediaEncoder;
             _itemRepository = itemRepository;
+            _persistenceService = persistenceService;
+            _nextUpService = nextUpService;
+            _countService = countService;
+            _linkedChildrenService = linkedChildrenService;
             _imageProcessor = imageProcessor;
 
             _cache = new FastConcurrentLru<Guid, BaseItem>(_configurationManager.Configuration.CacheSize);
@@ -158,10 +180,13 @@ namespace Emby.Server.Implementations.Library
             _namingOptions = namingOptions;
             _peopleRepository = peopleRepository;
             _pathManager = pathManager;
+            _dotIgnoreIgnoreRule = dotIgnoreIgnoreRule;
             _extraResolver = new ExtraResolver(loggerFactory.CreateLogger<ExtraResolver>(), namingOptions, directoryService);
 
             _configurationManager.ConfigurationUpdated += ConfigurationUpdated;
 
+            _mediaStreamRepository = mediaStreamRepository;
+
             RecordConfigurationValues(_configurationManager.Configuration);
         }
 
@@ -327,9 +352,17 @@ namespace Emby.Server.Implementations.Library
             DeleteItem(item, options, parent, notifyParentItem);
         }
 
-        public void DeleteItemsUnsafeFast(IEnumerable<BaseItem> items)
+        public void DeleteItemsUnsafeFast(IReadOnlyCollection<BaseItem> items, bool deleteSourceFiles = false)
         {
-            var pathMaps = items.Select(e => (Item: e, InternalPath: GetInternalMetadataPaths(e), DeletePaths: e.GetDeletePaths())).ToArray();
+            if (items.Count == 0)
+            {
+                return;
+            }
+
+            var pathMaps = items.Select(e =>
+                (Item: e,
+                InternalPath: GetInternalMetadataPaths(e),
+                DeletePaths: deleteSourceFiles ? e.GetDeletePaths() : [])).ToArray();
 
             foreach (var (item, internalPaths, pathsToDelete) in pathMaps)
             {
@@ -363,7 +396,7 @@ namespace Emby.Server.Implementations.Library
                 }
             }
 
-            _itemRepository.DeleteItem([.. pathMaps.Select(f => f.Item.Id)]);
+            _persistenceService.DeleteItem([.. pathMaps.Select(f => f.Item.Id)]);
         }
 
         public void DeleteItem(BaseItem item, DeleteOptions options, BaseItem parent, bool notifyParentItem)
@@ -406,6 +439,99 @@ namespace Emby.Server.Implementations.Library
                     item.Id);
             }
 
+            // If deleting a primary version video, clear PrimaryVersionId from alternate versions
+            // OwnerId check: items with OwnerId set are alternate versions or extras, not primaries
+            if (item is Video video && !video.PrimaryVersionId.HasValue && video.OwnerId.IsEmpty())
+            {
+                var localAlternateIds = GetLocalAlternateVersionIds(video).ToHashSet();
+                var allAlternateVersions = localAlternateIds
+                    .Concat(GetLinkedAlternateVersions(video).Select(v => v.Id))
+                    .Distinct()
+                    .Select(id => GetItemById(id))
+                    .OfType<Video>()
+                    .ToList();
+
+                // Partition alternates by whether their files still exist on disk
+                var alternateVersions = new List<Video>();
+                var missingAlternates = new List<Video>();
+                foreach (var alt in allAlternateVersions)
+                {
+                    if (!string.IsNullOrEmpty(alt.Path) && !_fileSystem.FileExists(alt.Path))
+                    {
+                        missingAlternates.Add(alt);
+                    }
+                    else
+                    {
+                        alternateVersions.Add(alt);
+                    }
+                }
+
+                // Delete alternates whose files no longer exist to avoid ghost items.
+                // Clear PrimaryVersionId first so DeleteItem doesn't try to update the primary being deleted.
+                foreach (var missing in missingAlternates)
+                {
+                    _logger.LogInformation(
+                        "Deleting missing alternate version {Name} ({Path})",
+                        missing.Name ?? "Unknown name",
+                        missing.Path ?? string.Empty);
+                    missing.SetPrimaryVersionId(null);
+                    missing.OwnerId = Guid.Empty;
+                    missing.LocalAlternateVersions = [];
+                    missing.LinkedAlternateVersions = [];
+                    DeleteItem(missing, new DeleteOptions { DeleteFileLocation = false }, false);
+                }
+
+                if (alternateVersions.Count > 0)
+                {
+                    _logger.LogInformation(
+                        "Clearing PrimaryVersionId from {Count} alternate versions of {Name}",
+                        alternateVersions.Count,
+                        item.Name ?? "Unknown name");
+
+                    // Promote the first alternate version to be the new primary
+                    var newPrimary = alternateVersions[0];
+                    newPrimary.SetPrimaryVersionId(null);
+                    newPrimary.OwnerId = Guid.Empty;
+
+                    // Transfer alternate version arrays from old primary to new primary
+                    // so UpdateToRepositoryAsync creates correct LinkedChildren entries
+                    newPrimary.LocalAlternateVersions = video.LocalAlternateVersions
+                        .Where(p => !string.Equals(p, newPrimary.Path, StringComparison.OrdinalIgnoreCase))
+                        .ToArray();
+                    newPrimary.LinkedAlternateVersions = video.LinkedAlternateVersions
+                        .Where(lc => !lc.ItemId.HasValue || !lc.ItemId.Value.Equals(newPrimary.Id))
+                        .ToArray();
+
+                    newPrimary.UpdateToRepositoryAsync(ItemUpdateType.MetadataEdit, CancellationToken.None).GetAwaiter().GetResult();
+
+                    // Re-route playlist/collection references from deleted primary to new primary
+                    RerouteLinkedChildReferencesAsync(video.Id, newPrimary.Id).GetAwaiter().GetResult();
+
+                    // Update remaining alternates to point to new primary
+                    foreach (var alternate in alternateVersions.Skip(1))
+                    {
+                        alternate.SetPrimaryVersionId(newPrimary.Id);
+                        // Only set OwnerId for local alternates; linked alternates are independent items
+                        alternate.OwnerId = localAlternateIds.Contains(alternate.Id) ? newPrimary.Id : Guid.Empty;
+                        alternate.UpdateToRepositoryAsync(ItemUpdateType.MetadataEdit, CancellationToken.None).GetAwaiter().GetResult();
+                    }
+                }
+            }
+            else if (item is Video alternateVideo && alternateVideo.PrimaryVersionId.HasValue)
+            {
+                // If deleting an alternate version, re-route references to its primary
+                RerouteLinkedChildReferencesAsync(alternateVideo.Id, alternateVideo.PrimaryVersionId.Value).GetAwaiter().GetResult();
+
+                // Remove deleted alternate from primary's LinkedAlternateVersions
+                if (GetItemById(alternateVideo.PrimaryVersionId.Value) is Video primaryVideo)
+                {
+                    primaryVideo.LinkedAlternateVersions = primaryVideo.LinkedAlternateVersions
+                        .Where(lc => !lc.ItemId.HasValue || !lc.ItemId.Value.Equals(alternateVideo.Id))
+                        .ToArray();
+                    primaryVideo.UpdateToRepositoryAsync(ItemUpdateType.MetadataEdit, CancellationToken.None).GetAwaiter().GetResult();
+                }
+            }
+
             var children = item.IsFolder
                 ? ((Folder)item).GetRecursiveChildren(false)
                 : [];
@@ -450,7 +576,7 @@ namespace Emby.Server.Implementations.Library
 
             item.SetParent(null);
 
-            _itemRepository.DeleteItem([item.Id, .. children.Select(f => f.Id)]);
+            _persistenceService.DeleteItem([item.Id, .. children.Select(f => f.Id)]);
             _cache.TryRemove(item.Id, out _);
             foreach (var child in children)
             {
@@ -576,6 +702,9 @@ namespace Emby.Server.Implementations.Library
                 // Trickplay
                 list.Add(_pathManager.GetTrickplayDirectory(video));
 
+                // Chapter Images
+                list.Add(_pathManager.GetChapterImageFolderPath(video));
+
                 // Subtitles and attachments
                 foreach (var mediaSource in item.GetMediaSources(false))
                 {
@@ -657,8 +786,99 @@ namespace Emby.Server.Implementations.Library
             return key.GetMD5();
         }
 
-        public BaseItem? ResolvePath(FileSystemMetadata fileInfo, Folder? parent = null, IDirectoryService? directoryService = null)
+        public BaseItem? ResolvePath(
-            => ResolvePath(fileInfo, directoryService ?? new DirectoryService(_fileSystem), null, parent);
+            FileSystemMetadata fileInfo,
+            Folder? parent = null,
+            IDirectoryService? directoryService = null,
+            CollectionType? collectionType = null)
+            => ResolvePath(fileInfo, directoryService ?? new DirectoryService(_fileSystem), null, parent, collectionType);
+
+        private void SetAdditionalPartsFromStack(Video altVideo, string path)
+        {
+            if (altVideo.AdditionalParts is { Length: > 0 })
+            {
+                return;
+            }
+
+            var directory = Path.GetDirectoryName(path);
+            if (string.IsNullOrEmpty(directory))
+            {
+                return;
+            }
+
+            IEnumerable<FileSystemMetadata> siblings;
+            try
+            {
+                siblings = _fileSystem.GetFiles(directory);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogWarning(ex, "Failed to enumerate siblings to detect stack for {Path}", path);
+                return;
+            }
+
+            var stacks = StackResolver.Resolve(siblings, _namingOptions);
+            foreach (var stack in stacks)
+            {
+                if (stack.Files.Count > 1
+                    && string.Equals(stack.Files[0], path, StringComparison.OrdinalIgnoreCase))
+                {
+                    altVideo.AdditionalParts = stack.Files.Skip(1).ToArray();
+                    return;
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        public Video? ResolveAlternateVersion(string path, Type expectedVideoType, Folder? parent, CollectionType? collectionType)
+        {
+            // Clean up any existing item saved with wrong type (e.g. Video instead of Movie).
+            // This happens when items were previously resolved without proper type context
+            // in mixed-content libraries where collectionType is null.
+            var expectedId = GetNewItemId(path, expectedVideoType);
+            if (expectedVideoType != typeof(Video))
+            {
+                var wrongTypeId = GetNewItemId(path, typeof(Video));
+                if (!wrongTypeId.Equals(expectedId) && GetItemById(wrongTypeId) is Video wrongTypeItem)
+                {
+                    _logger.LogInformation(
+                        "Removing alternate version with wrong type {WrongType}, expected {ExpectedType}: {Path}",
+                        wrongTypeItem.GetType().Name,
+                        expectedVideoType.Name,
+                        path);
+                    DeleteItem(wrongTypeItem, new DeleteOptions { DeleteFileLocation = false });
+                }
+            }
+
+            var resolved = ResolvePath(
+                _fileSystem.GetFileSystemInfo(path),
+                parent,
+                collectionType: collectionType) as Video;
+
+            if (resolved is null)
+            {
+                return null;
+            }
+
+            // Ensure the alternate version has the same concrete type as the primary video.
+            // ResolvePath may return a generic Video for files in mixed-content libraries
+            // where collectionType is null, even though the primary is a Movie/Episode/etc.
+            if (resolved.GetType() != expectedVideoType)
+            {
+                if (Activator.CreateInstance(expectedVideoType) is Video correctVideo)
+                {
+                    correctVideo.Path = resolved.Path;
+                    correctVideo.Name = resolved.Name;
+                    correctVideo.VideoType = resolved.VideoType;
+                    correctVideo.ProductionYear = resolved.ProductionYear;
+                    correctVideo.ExtraType = resolved.ExtraType;
+                    resolved = correctVideo;
+                }
+            }
+
+            resolved.Id = expectedId;
+            return resolved;
+        }
 
         private BaseItem? ResolvePath(
             FileSystemMetadata fileInfo,
@@ -1041,7 +1261,7 @@ namespace Emby.Server.Implementations.Library
 
         public IReadOnlyDictionary<string, MusicArtist[]> GetArtists(IReadOnlyList<string> names)
         {
-            return _itemRepository.FindArtists(names);
+            return _linkedChildrenService.FindArtists(names);
         }
 
         public MusicArtist GetArtist(string name, DtoOptions options)
@@ -1131,6 +1351,7 @@ namespace Emby.Server.Implementations.Library
         public async Task ValidateMediaLibraryInternal(IProgress<double> progress, CancellationToken cancellationToken)
         {
             IsScanRunning = true;
+            ClearIgnoreRuleCache();
             LibraryMonitor.Stop();
 
             try
@@ -1139,6 +1360,7 @@ namespace Emby.Server.Implementations.Library
             }
             finally
             {
+                ClearIgnoreRuleCache();
                 LibraryMonitor.Start();
                 IsScanRunning = false;
             }
@@ -1146,6 +1368,7 @@ namespace Emby.Server.Implementations.Library
 
         public async Task ValidateTopLibraryFolders(CancellationToken cancellationToken, bool removeRoot = false)
         {
+            ClearIgnoreRuleCache();
             RootFolder.Children = null;
             await RootFolder.RefreshMetadata(cancellationToken).ConfigureAwait(false);
 
@@ -1186,8 +1409,16 @@ namespace Emby.Server.Implementations.Library
 
             if (toDelete.Count > 0)
             {
-                _itemRepository.DeleteItem(toDelete.ToArray());
+                _persistenceService.DeleteItem(toDelete.ToArray());
             }
+
+            ClearIgnoreRuleCache();
+        }
+
+        /// <inheritdoc />
+        public void ClearIgnoreRuleCache()
+        {
+            _dotIgnoreIgnoreRule.ClearDirectoryCache();
         }
 
         private async Task PerformLibraryValidation(IProgress<double> progress, CancellationToken cancellationToken)
@@ -1262,7 +1493,7 @@ namespace Emby.Server.Implementations.Library
                 progress.Report(percent * 100);
             }
 
-            _itemRepository.UpdateInheritedValues();
+            _persistenceService.UpdateInheritedValues();
 
             progress.Report(100);
         }
@@ -1421,14 +1652,7 @@ namespace Emby.Server.Implementations.Library
                 AddUserToQuery(query, query.User, allowExternalContent);
             }
 
-            var itemList = _itemRepository.GetItemList(query);
+            return _itemRepository.GetItemList(query);
-            var user = query.User;
-            if (user is not null)
-            {
-                return itemList.Where(i => i.IsVisible(user)).ToList();
-            }
-
-            return itemList;
         }
 
         public IReadOnlyList<BaseItem> GetItemList(InternalItemsQuery query)
@@ -1452,7 +1676,7 @@ namespace Emby.Server.Implementations.Library
                 AddUserToQuery(query, query.User);
             }
 
-            return _itemRepository.GetCount(query);
+            return _countService.GetCount(query);
         }
 
         public ItemCounts GetItemCounts(InternalItemsQuery query)
@@ -1471,7 +1695,30 @@ namespace Emby.Server.Implementations.Library
                 AddUserToQuery(query, query.User);
             }
 
-            return _itemRepository.GetItemCounts(query);
+            return _countService.GetItemCounts(query);
+        }
+
+        /// <inheritdoc/>
+        public ItemCounts GetItemCountsForNameItem(BaseItemKind kind, Guid id, BaseItemKind[] relatedItemKinds, User? user)
+        {
+            var query = new InternalItemsQuery(user);
+            if (user is not null)
+            {
+                AddUserToQuery(query, user);
+            }
+
+            return _countService.GetItemCountsForNameItem(kind, id, relatedItemKinds, query);
+        }
+
+        public Dictionary<Guid, int> GetChildCountBatch(IReadOnlyList<Guid> parentIds, Guid? userId)
+        {
+            return _countService.GetChildCountBatch(parentIds, userId);
+        }
+
+        /// <inheritdoc/>
+        public Dictionary<Guid, (int Played, int Total)> GetPlayedAndTotalCountBatch(IReadOnlyList<Guid> folderIds, User user)
+        {
+            return _countService.GetPlayedAndTotalCountBatch(folderIds, user);
         }
 
         public IReadOnlyList<BaseItem> GetItemList(InternalItemsQuery query, List<BaseItem> parents)
@@ -1516,7 +1763,17 @@ namespace Emby.Server.Implementations.Library
                 }
             }
 
-            return _itemRepository.GetNextUpSeriesKeys(query, dateCutoff);
+            return _nextUpService.GetNextUpSeriesKeys(query, dateCutoff);
+        }
+
+        /// <inheritdoc />
+        public IReadOnlyDictionary<string, MediaBrowser.Controller.Persistence.NextUpEpisodeBatchResult> GetNextUpEpisodesBatch(
+            InternalItemsQuery query,
+            IReadOnlyList<string> seriesKeys,
+            bool includeSpecials,
+            bool includeWatchedForRewatching)
+        {
+            return _nextUpService.GetNextUpEpisodesBatch(query, seriesKeys, includeSpecials, includeWatchedForRewatching);
         }
 
         public QueryResult<BaseItem> QueryItems(InternalItemsQuery query)
@@ -1683,6 +1940,25 @@ namespace Emby.Server.Implementations.Library
                     query.TopParentIds = [Guid.NewGuid()];
                 }
             }
+            else if (parents.Count == 1 && parents.First() is Folder folder
+                && (folder is Playlist || folder is BoxSet)
+                && folder.LinkedChildren.Length > 0)
+            {
+                // Playlists and BoxSets store their contents in LinkedChildren and never
+                // populate AncestorIds for those items, so a recursive AncestorIds query
+                // would return zero rows. Resolve to the linked child IDs up front and
+                // route through the existing indexed ItemIds filter.
+                query.ItemIds = folder.LinkedChildren
+                    .Where(lc => lc.ItemId.HasValue && !lc.ItemId.Value.IsEmpty())
+                    .Select(lc => lc.ItemId!.Value)
+                    .ToArray();
+
+                // Empty linked-children should still return empty rather than scanning everything.
+                if (query.ItemIds.Length == 0)
+                {
+                    query.ItemIds = [Guid.NewGuid()];
+                }
+            }
             else
             {
                 // We need to be able to query from any arbitrary ancestor up the tree
@@ -1700,6 +1976,11 @@ namespace Emby.Server.Implementations.Library
 
         private void AddUserToQuery(InternalItemsQuery query, User user, bool allowExternalContent = true)
         {
+            if (query.User is null)
+            {
+                query.SetUser(user);
+            }
+
             if (query.AncestorIds.Length == 0 &&
                 query.ParentId.IsEmpty() &&
                 query.ChannelIds.Count == 0 &&
@@ -1725,6 +2006,15 @@ namespace Emby.Server.Implementations.Library
             }
         }
 
+        /// <inheritdoc/>
+        public void ConfigureUserAccess(InternalItemsQuery query, User user)
+        {
+            ArgumentNullException.ThrowIfNull(query);
+            ArgumentNullException.ThrowIfNull(user);
+
+            AddUserToQuery(query, user);
+        }
+
         private IEnumerable<Guid> GetTopParentIdsForQuery(BaseItem item, User? user)
         {
             if (item is UserView view)
@@ -1889,6 +2179,44 @@ namespace Emby.Server.Implementations.Library
             return video;
         }
 
+        /// <inheritdoc />
+        public IEnumerable<Guid> GetLocalAlternateVersionIds(Video video)
+        {
+            ArgumentNullException.ThrowIfNull(video);
+
+            var linkedIds = _linkedChildrenService.GetLinkedChildrenIds(video.Id, (int)MediaBrowser.Controller.Entities.LinkedChildType.LocalAlternateVersion);
+            if (linkedIds.Count > 0)
+            {
+                return linkedIds;
+            }
+
+            return [];
+        }
+
+        /// <inheritdoc />
+        public IEnumerable<Video> GetLinkedAlternateVersions(Video video)
+        {
+            ArgumentNullException.ThrowIfNull(video);
+
+            var linkedIds = _linkedChildrenService.GetLinkedChildrenIds(video.Id, (int)MediaBrowser.Controller.Entities.LinkedChildType.LinkedAlternateVersion);
+            if (linkedIds.Count > 0)
+            {
+                return linkedIds
+                    .Select(id => GetItemById(id))
+                    .Where(i => i is not null)
+                    .OfType<Video>()
+                    .OrderBy(i => i.SortName);
+            }
+
+            return [];
+        }
+
+        /// <inheritdoc />
+        public void UpsertLinkedChild(Guid parentId, Guid childId, MediaBrowser.Controller.Entities.LinkedChildType childType)
+        {
+            _linkedChildrenService.UpsertLinkedChild(parentId, childId, childType);
+        }
+
         /// <inheritdoc />
         public IEnumerable<BaseItem> Sort(IEnumerable<BaseItem> items, User? user, IEnumerable<ItemSortBy> sortBy, SortOrder sortOrder)
         {
@@ -1993,9 +2321,48 @@ namespace Emby.Server.Implementations.Library
         /// <inheritdoc />
         public void CreateItems(IReadOnlyList<BaseItem> items, BaseItem? parent, CancellationToken cancellationToken)
         {
-            _itemRepository.SaveItems(items, cancellationToken);
+            // Resolve and add any local alternate version items that don't exist yet
-
+            // This ensures they exist in the database when LinkedChildren are processed
+            var allItems = new List<BaseItem>(items);
+            var parentFolder = parent as Folder;
+            var parentCollectionType = parent is not null ? GetTopFolderContentType(parent) : null;
             foreach (var item in items)
+            {
+                if (item is Video video && video.LocalAlternateVersions.Length > 0)
+                {
+                    var videoType = video.GetType();
+                    foreach (var path in video.LocalAlternateVersions)
+                    {
+                        if (string.IsNullOrEmpty(path))
+                        {
+                            continue;
+                        }
+
+                        // Use the primary video's type for ID calculation to ensure consistency
+                        var altId = GetNewItemId(path, videoType);
+                        if (GetItemById(altId) is null && !allItems.Any(i => i.Id.Equals(altId)))
+                        {
+                            // Alternate version doesn't exist, resolve and create it
+                            // ensuring it has the same type as the primary video
+                            var altVideo = ResolveAlternateVersion(path, videoType, parentFolder, parentCollectionType);
+                            if (altVideo is not null)
+                            {
+                                altVideo.OwnerId = video.Id;
+                                altVideo.SetPrimaryVersionId(video.Id);
+                                // ResolveAlternateVersion only sees the alternate's primary file.
+                                // If the alternate is itself a stack (e.g. 1080p part1 + part2),
+                                // detect its parts from sibling files so its AdditionalParts persist.
+                                SetAdditionalPartsFromStack(altVideo, path);
+                                allItems.Add(altVideo);
+                            }
+                        }
+                    }
+                }
+            }
+
+            _persistenceService.SaveItems(allItems, cancellationToken);
+
+            foreach (var item in allItems)
             {
                 RegisterItem(item);
             }
@@ -2144,7 +2511,7 @@ namespace Emby.Server.Implementations.Library
 
             item.ValidateImages();
 
-            _itemRepository.SaveImages(item);
+            await _persistenceService.SaveImagesAsync(item).ConfigureAwait(false);
 
             RegisterItem(item);
         }
@@ -2161,7 +2528,54 @@ namespace Emby.Server.Implementations.Library
                 item.DateLastSaved = DateTime.UtcNow;
             }
 
-            _itemRepository.SaveItems(items, cancellationToken);
+            // Resolve and add any local alternate version items that don't exist yet
+            // This ensures they exist in the database when LinkedChildren are processed
+            var allItems = new List<BaseItem>(items);
+            var parentFolder = parent as Folder;
+            var parentCollectionType = GetTopFolderContentType(parent);
+            foreach (var item in items)
+            {
+                if (item is Video video && video.LocalAlternateVersions.Length > 0)
+                {
+                    var videoType = video.GetType();
+                    foreach (var path in video.LocalAlternateVersions)
+                    {
+                        if (string.IsNullOrEmpty(path))
+                        {
+                            continue;
+                        }
+
+                        // Use the primary video's type for ID calculation to ensure consistency
+                        var altId = GetNewItemId(path, videoType);
+                        if (GetItemById(altId) is null && !allItems.Any(i => i.Id.Equals(altId)))
+                        {
+                            // Alternate version doesn't exist, resolve and create it
+                            // ensuring it has the same type as the primary video
+                            var altVideo = ResolveAlternateVersion(path, videoType, parentFolder, parentCollectionType);
+                            if (altVideo is not null)
+                            {
+                                altVideo.OwnerId = video.Id;
+                                altVideo.SetPrimaryVersionId(video.Id);
+                                // ResolveAlternateVersion only sees the alternate's primary file.
+                                // If the alternate is itself a stack (e.g. 1080p part1 + part2),
+                                // detect its parts from sibling files so its AdditionalParts persist.
+                                SetAdditionalPartsFromStack(altVideo, path);
+                                allItems.Add(altVideo);
+                            }
+                        }
+                    }
+                }
+            }
+
+            _persistenceService.SaveItems(allItems, cancellationToken);
+
+            foreach (var item in allItems)
+            {
+                if (!items.Contains(item))
+                {
+                    RegisterItem(item);
+                }
+            }
 
             if (parent is Folder folder)
             {
@@ -2202,6 +2616,12 @@ namespace Emby.Server.Implementations.Library
         public Task UpdateItemAsync(BaseItem item, BaseItem parent, ItemUpdateType updateReason, CancellationToken cancellationToken)
             => UpdateItemsAsync([item], parent, updateReason, cancellationToken);
 
+        /// <inheritdoc />
+        public async Task ReattachUserDataAsync(BaseItem item, CancellationToken cancellationToken)
+        {
+            await _persistenceService.ReattachUserDataAsync(item, cancellationToken).ConfigureAwait(false);
+        }
+
         public async Task RunMetadataSavers(BaseItem item, ItemUpdateType updateReason)
         {
             if (item.IsFileProtocol)
@@ -2283,7 +2703,7 @@ namespace Emby.Server.Implementations.Library
 
             if (item is null)
             {
-                return new List<Folder>();
+                return [];
             }
 
             return GetCollectionFoldersInternal(item, allUserRootChildren);
@@ -2827,8 +3247,9 @@ namespace Emby.Server.Implementations.Library
         public IEnumerable<BaseItem> FindExtras(BaseItem owner, IReadOnlyList<FileSystemMetadata> fileSystemChildren, IDirectoryService directoryService)
         {
             // Apply .ignore rules
-            var filtered = fileSystemChildren.Where(c => !DotIgnoreIgnoreRule.IsIgnored(c, owner)).ToList();
+            var filtered = fileSystemChildren.Where(c => !_dotIgnoreIgnoreRule.ShouldIgnore(c, owner)).ToList();
-            var ownerVideoInfo = VideoResolver.Resolve(owner.Path, owner.IsFolder, _namingOptions, libraryRoot: owner.ContainingFolderPath);
+            var isFolder = owner.IsFolder || (owner is Video video && (video.VideoType == VideoType.BluRay || video.VideoType == VideoType.Dvd));
+            var ownerVideoInfo = VideoResolver.Resolve(owner.Path, isFolder, _namingOptions, libraryRoot: owner.ContainingFolderPath);
             if (ownerVideoInfo is null)
             {
                 yield break;
@@ -2890,10 +3311,16 @@ namespace Emby.Server.Implementations.Library
                     extra.ExtraType = extraType;
                 }
 
-                extra.ParentId = Guid.Empty;
+                // Only return items that are actual extras (have ExtraType set)
-                extra.OwnerId = owner.Id;
+                // Note: OwnerId and ParentId are set by RefreshExtras, not here,
-                extra.IsInMixedFolder = isInMixedFolder;
+                // so that RefreshExtras can detect when they need updating and set ForceSave.
-                return extra;
+                if (extra.ExtraType is not null)
+                {
+                    extra.IsInMixedFolder = isInMixedFolder;
+                    return extra;
+                }
+
+                return null;
             }
         }
 
@@ -2912,7 +3339,7 @@ namespace Emby.Server.Implementations.Library
 
         public IReadOnlyList<PersonInfo> GetPeople(InternalPeopleQuery query)
         {
-            return _peopleRepository.GetPeople(query);
+            return _peopleRepository.GetPeople(query).Items;
         }
 
         public IReadOnlyList<PersonInfo> GetPeople(BaseItem item)
@@ -2933,24 +3360,33 @@ namespace Emby.Server.Implementations.Library
             return [];
         }
 
-        public IReadOnlyList<Person> GetPeopleItems(InternalPeopleQuery query)
+        public QueryResult<BaseItem> GetPeopleItems(InternalPeopleQuery query)
         {
-            return _peopleRepository.GetPeopleNames(query)
+            var queryResult = _peopleRepository.GetPeople(query);
-            .Select(i =>
+            var baseItems = queryResult.Items.Select(i =>
+                {
+                    try
+                    {
+                        return GetPerson(i.Name);
+                    }
+                    catch (Exception ex)
+                    {
+                        _logger.LogError(ex, "error retrieving BaseItem for person: {0}", i.Name);
+                        return null;
+                    }
+                })
+                .Where(i => i is not null)
+                .Where(i => query.User is null || i!.IsVisible(query.User))
+                .OfType<BaseItem>()
+                .ToList()
+                .AsReadOnly();
+
+            return new QueryResult<BaseItem>
             {
-                try
+                StartIndex = queryResult.StartIndex,
-                {
+                TotalRecordCount = queryResult.TotalRecordCount,
-                    return GetPerson(i);
+                Items = baseItems,
-                }
+            };
-                catch (Exception ex)
-                {
-                    _logger.LogError(ex, "Error getting person");
-                    return null;
-                }
-            })
-            .Where(i => i is not null)
-            .Where(i => query.User is null || i!.IsVisible(query.User))
-            .ToList()!; // null values are filtered out
         }
 
         public IReadOnlyList<string> GetPeopleNames(InternalPeopleQuery query)
@@ -3195,19 +3631,7 @@ namespace Emby.Server.Implementations.Library
             var rootFolderPath = _configurationManager.ApplicationPaths.DefaultUserViewsPath;
             var virtualFolderPath = Path.Combine(rootFolderPath, virtualFolderName);
 
-            var shortcutFilename = Path.GetFileNameWithoutExtension(path);
+            CreateShortcut(virtualFolderPath, pathInfo);
-
-            var lnk = Path.Combine(virtualFolderPath, shortcutFilename + ShortcutFileExtension);
-
-            while (File.Exists(lnk))
-            {
-                shortcutFilename += "1";
-                lnk = Path.Combine(virtualFolderPath, shortcutFilename + ShortcutFileExtension);
-            }
-
-            _fileSystem.CreateShortcut(lnk, _appHost.ReverseVirtualPath(path));
-
-            RemoveContentTypeOverrides(path);
 
             if (saveLibraryOptions)
             {
@@ -3372,5 +3796,65 @@ namespace Emby.Server.Implementations.Library
 
             return item is UserRootFolder || item.IsVisibleStandalone(user);
         }
+
+        public void CreateShortcut(string virtualFolderPath, MediaPathInfo pathInfo)
+        {
+            var path = pathInfo.Path;
+            var rootFolderPath = _configurationManager.ApplicationPaths.DefaultUserViewsPath;
+
+            var shortcutFilename = Path.GetFileNameWithoutExtension(path);
+
+            var lnk = Path.Combine(virtualFolderPath, shortcutFilename + ShortcutFileExtension);
+
+            while (File.Exists(lnk))
+            {
+                shortcutFilename += "1";
+                lnk = Path.Combine(virtualFolderPath, shortcutFilename + ShortcutFileExtension);
+            }
+
+            _fileSystem.CreateShortcut(lnk, _appHost.ReverseVirtualPath(path));
+            RemoveContentTypeOverrides(path);
+        }
+
+        /// <inheritdoc />
+        public async Task RerouteLinkedChildReferencesAsync(Guid fromChildId, Guid toChildId)
+        {
+            var affectedParentIds = _linkedChildrenService.RerouteLinkedChildren(fromChildId, toChildId);
+
+            // Update in-memory LinkedChildren and re-save metadata (NFO) for affected parents
+            foreach (var parentId in affectedParentIds)
+            {
+                if (GetItemById(parentId) is Folder parent)
+                {
+                    foreach (var lc in parent.LinkedChildren)
+                    {
+                        if (lc.ItemId.HasValue && lc.ItemId.Value.Equals(fromChildId))
+                        {
+                            lc.ItemId = toChildId;
+                        }
+                    }
+
+                    await RunMetadataSavers(parent, ItemUpdateType.MetadataEdit).ConfigureAwait(false);
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        public QueryFiltersLegacy GetQueryFiltersLegacy(InternalItemsQuery query)
+        {
+            if (query.User is not null)
+            {
+                AddUserToQuery(query, query.User);
+            }
+
+            SetTopParentOrAncestorIds(query);
+            return _itemRepository.GetQueryFiltersLegacy(query);
+        }
+
+        /// <inheritdoc />
+        public IReadOnlyList<string> GetMediaStreamLanguages(MediaStreamType mediaStreamType)
+        {
+            return _mediaStreamRepository.GetMediaStreamLanguages(mediaStreamType);
+        }
     }
 }

Emby.Server.Implementations/Library/MediaSourceManager.cs

@@ -23,6 +23,7 @@ using MediaBrowser.Common.Configuration;
 using MediaBrowser.Common.Extensions;
 using MediaBrowser.Controller;
 using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Entities.TV;
 using MediaBrowser.Controller.Library;
 using MediaBrowser.Controller.LiveTv;
 using MediaBrowser.Controller.MediaEncoding;
@@ -423,7 +424,7 @@ namespace Emby.Server.Implementations.Library
             MediaStreamSelector.SetSubtitleStreamScores(source.MediaStreams, preferredSubs, user.SubtitleMode, audioLanguage);
         }
 
-        private void SetDefaultAudioStreamIndex(MediaSourceInfo source, UserItemData userData, User user, bool allowRememberingSelection)
+        private void SetDefaultAudioStreamIndex(MediaSourceInfo source, UserItemData userData, User user, bool allowRememberingSelection, string originalLanguage)
         {
             if (userData is not null && userData.AudioStreamIndex.HasValue && user.RememberAudioSelections && allowRememberingSelection)
             {
@@ -437,7 +438,42 @@ namespace Emby.Server.Implementations.Library
                 }
             }
 
-            var preferredAudio = NormalizeLanguage(user.AudioLanguagePreference);
+            if (string.Equals(user.AudioLanguagePreference, "OriginalLanguage", StringComparison.OrdinalIgnoreCase))
+            {
+                originalLanguage = !string.IsNullOrWhiteSpace(originalLanguage)
+                    ? originalLanguage.Split(',').FirstOrDefault()
+                    : null;
+
+                if (user.PlayDefaultAudioTrack)
+                {
+                    source.DefaultAudioStreamIndex = MediaStreamSelector.GetDefaultAudioStreamIndex(
+                        source.MediaStreams,
+                        NormalizeLanguage(originalLanguage),
+                        user.PlayDefaultAudioTrack);
+                    return;
+                }
+
+                var originalIndex = source.MediaStreams.FindIndex(i => i.Type == MediaStreamType.Audio && i.IsOriginal);
+
+                if (!string.IsNullOrWhiteSpace(originalLanguage) && originalIndex != -1)
+                {
+                    var mediaLanguageOriginal = source.MediaStreams[originalIndex].Language;
+                    if (NormalizeLanguage(mediaLanguageOriginal).Contains(NormalizeLanguage(originalLanguage).FirstOrDefault()))
+                    {
+                        source.DefaultAudioStreamIndex = originalIndex;
+                        return;
+                    }
+                }
+                else if (originalIndex != -1)
+                {
+                    source.DefaultAudioStreamIndex = originalIndex;
+                    return;
+                }
+            }
+
+            var preferredAudio = string.Equals(user.AudioLanguagePreference, "OriginalLanguage", StringComparison.OrdinalIgnoreCase) && !string.IsNullOrWhiteSpace(originalLanguage)
+                ? NormalizeLanguage(originalLanguage)
+                : NormalizeLanguage(user.AudioLanguagePreference);
 
             source.DefaultAudioStreamIndex = MediaStreamSelector.GetDefaultAudioStreamIndex(source.MediaStreams, preferredAudio, user.PlayDefaultAudioTrack);
             if (user.PlayDefaultAudioTrack)
@@ -462,7 +498,19 @@ namespace Emby.Server.Implementations.Library
 
                 var allowRememberingSelection = item is null || item.EnableRememberingTrackSelections;
 
-                SetDefaultAudioStreamIndex(source, userData, user, allowRememberingSelection);
+                var originalLanguage = item?.OriginalLanguage ?? item switch
+                {
+                    Episode episode => episode.Series.OriginalLanguage,
+                    Video video => video.GetOwner() switch
+                    {
+                        Episode ownerEpisode => ownerEpisode.OriginalLanguage ?? ownerEpisode.Series.OriginalLanguage,
+                        BaseItem owner => owner.OriginalLanguage,
+                        null => null
+                    },
+                    _ => null
+                };
+
+                SetDefaultAudioStreamIndex(source, userData, user, allowRememberingSelection, originalLanguage);
                 SetDefaultSubtitleStreamIndex(source, userData, user, allowRememberingSelection);
             }
             else if (mediaType == MediaType.Audio)

Emby.Server.Implementations/Library/PathExtensions.cs

@@ -37,15 +37,25 @@ namespace Emby.Server.Implementations.Library
             while (attributeIndex > -1 && attributeIndex < maxIndex)
             {
                 var attributeEnd = attributeIndex + attribute.Length;
-                if (attributeIndex > 0
+                if (attributeIndex > 0)
-                    && str[attributeIndex - 1] == '['
-                    && (str[attributeEnd] == '=' || str[attributeEnd] == '-'))
                 {
-                    var closingIndex = str[attributeEnd..].IndexOf(']');
+                    var attributeOpener = str[attributeIndex - 1];
-                    // Must be at least 1 character before the closing bracket.
+                    var attributeCloser = attributeOpener switch
-                    if (closingIndex > 1)
                     {
-                        return str[(attributeEnd + 1)..(attributeEnd + closingIndex)].Trim().ToString();
+                        '[' => ']',
+                        '(' => ')',
+                        '{' => '}',
+                         _ => '\0'
+                    };
+                    if (attributeCloser != '\0' && (str[attributeEnd] == '=' || str[attributeEnd] == '-'))
+                    {
+                        var closingIndex = str[attributeEnd..].IndexOf(attributeCloser);
+
+                        // Must be at least 1 character before the closing bracket.
+                        if (closingIndex > 1)
+                        {
+                            return str[(attributeEnd + 1)..(attributeEnd + closingIndex)].Trim().ToString();
+                        }
                     }
                 }
 
@@ -60,6 +70,16 @@ namespace Emby.Server.Implementations.Library
                 return match ? imdbId.ToString() : null;
             }
 
+            // Allow tmdb as an alias for tmdbid
+            if (attribute.Equals("tmdbid", StringComparison.OrdinalIgnoreCase))
+            {
+                var tmdbValue = str.GetAttributeValue("tmdb");
+                if (tmdbValue is not null)
+                {
+                    return tmdbValue;
+                }
+            }
+
             return null;
         }
 

Emby.Server.Implementations/Library/PathManager.cs

@@ -6,6 +6,7 @@ using MediaBrowser.Common.Configuration;
 using MediaBrowser.Controller.Configuration;
 using MediaBrowser.Controller.Entities;
 using MediaBrowser.Controller.IO;
+using Microsoft.Extensions.Logging;
 
 namespace Emby.Server.Implementations.Library;
 
@@ -14,18 +15,22 @@ namespace Emby.Server.Implementations.Library;
 /// </summary>
 public class PathManager : IPathManager
 {
+    private readonly ILogger<PathManager> _logger;
     private readonly IServerConfigurationManager _config;
     private readonly IApplicationPaths _appPaths;
 
     /// <summary>
     /// Initializes a new instance of the <see cref="PathManager"/> class.
     /// </summary>
+    /// <param name="logger">The logger.</param>
     /// <param name="config">The server configuration manager.</param>
     /// <param name="appPaths">The application paths.</param>
     public PathManager(
+        ILogger<PathManager> logger,
         IServerConfigurationManager config,
         IApplicationPaths appPaths)
     {
+        _logger = logger;
         _config = config;
         _appPaths = appPaths;
     }
@@ -35,31 +40,43 @@ public class PathManager : IPathManager
     private string AttachmentCachePath => Path.Combine(_appPaths.DataPath, "attachments");
 
     /// <inheritdoc />
-    public string GetAttachmentPath(string mediaSourceId, string fileName)
+    public string? GetAttachmentPath(string mediaSourceId, string fileName)
     {
-        return Path.Combine(GetAttachmentFolderPath(mediaSourceId), fileName);
+        var folder = GetAttachmentFolderPath(mediaSourceId);
+        return folder is null ? null : Path.Combine(folder, fileName);
     }
 
     /// <inheritdoc />
-    public string GetAttachmentFolderPath(string mediaSourceId)
+    public string? GetAttachmentFolderPath(string mediaSourceId)
     {
-        var id = Guid.Parse(mediaSourceId).ToString("D", CultureInfo.InvariantCulture).AsSpan();
+        if (!Guid.TryParse(mediaSourceId, out var parsed))
+        {
+            _logger.LogDebug("MediaSource Id '{MediaSourceId}' is not a GUID; no on-disk attachment folder.", mediaSourceId);
+            return null;
+        }
 
+        var id = parsed.ToString("D", CultureInfo.InvariantCulture).AsSpan();
         return Path.Join(AttachmentCachePath, id[..2], id);
     }
 
     /// <inheritdoc />
-    public string GetSubtitleFolderPath(string mediaSourceId)
+    public string? GetSubtitleFolderPath(string mediaSourceId)
     {
-        var id = Guid.Parse(mediaSourceId).ToString("D", CultureInfo.InvariantCulture).AsSpan();
+        if (!Guid.TryParse(mediaSourceId, out var parsed))
+        {
+            _logger.LogDebug("MediaSource Id '{MediaSourceId}' is not a GUID; no on-disk subtitle folder.", mediaSourceId);
+            return null;
+        }
 
+        var id = parsed.ToString("D", CultureInfo.InvariantCulture).AsSpan();
         return Path.Join(SubtitleCachePath, id[..2], id);
     }
 
     /// <inheritdoc />
-    public string GetSubtitlePath(string mediaSourceId, int streamIndex, string extension)
+    public string? GetSubtitlePath(string mediaSourceId, int streamIndex, string extension)
     {
-        return Path.Combine(GetSubtitleFolderPath(mediaSourceId), streamIndex.ToString(CultureInfo.InvariantCulture) + extension);
+        var folder = GetSubtitleFolderPath(mediaSourceId);
+        return folder is null ? null : Path.Combine(folder, streamIndex.ToString(CultureInfo.InvariantCulture) + extension);
     }
 
     /// <inheritdoc />
@@ -90,12 +107,23 @@ public class PathManager : IPathManager
     public IReadOnlyList<string> GetExtractedDataPaths(BaseItem item)
     {
         var mediaSourceId = item.Id.ToString("N", CultureInfo.InvariantCulture);
-        return [
+        List<string> paths = [];
-            GetAttachmentFolderPath(mediaSourceId),
+        var attachmentFolder = GetAttachmentFolderPath(mediaSourceId);
-            GetSubtitleFolderPath(mediaSourceId),
+        if (attachmentFolder is not null)
-            GetTrickplayDirectory(item, false),
+        {
-            GetTrickplayDirectory(item, true),
+            paths.Add(attachmentFolder);
-            GetChapterImageFolderPath(item)
+        }
-        ];
+
+        var subtitleFolder = GetSubtitleFolderPath(mediaSourceId);
+        if (subtitleFolder is not null)
+        {
+            paths.Add(subtitleFolder);
+        }
+
+        paths.Add(GetTrickplayDirectory(item, false));
+        paths.Add(GetTrickplayDirectory(item, true));
+        paths.Add(GetChapterImageFolderPath(item));
+
+        return paths;
     }
 }

Emby.Server.Implementations/Library/Resolvers/Books/BookResolver.cs

@@ -5,12 +5,12 @@
 using System;
 using System.IO;
 using System.Linq;
+using Emby.Naming.Book;
 using Jellyfin.Data.Enums;
 using Jellyfin.Extensions;
 using MediaBrowser.Controller.Entities;
 using MediaBrowser.Controller.Library;
 using MediaBrowser.Controller.Resolvers;
-using MediaBrowser.Model.Entities;
 
 namespace Emby.Server.Implementations.Library.Resolvers.Books
 {
@@ -35,17 +35,22 @@ namespace Emby.Server.Implementations.Library.Resolvers.Books
 
             var extension = Path.GetExtension(args.Path.AsSpan());
 
-            if (_validExtensions.Contains(extension, StringComparison.OrdinalIgnoreCase))
+            if (!_validExtensions.Contains(extension, StringComparison.OrdinalIgnoreCase))
             {
-                // It's a book
+                return null;
-                return new Book
-                {
-                    Path = args.Path,
-                    IsInMixedFolder = true
-                };
             }
 
-            return null;
+            var result = BookFileNameParser.Parse(Path.GetFileNameWithoutExtension(args.Path));
+
+            return new Book
+            {
+                Path = args.Path,
+                Name = result.Name ?? string.Empty,
+                IndexNumber = result.Index,
+                ProductionYear = result.Year,
+                SeriesName = result.SeriesName ?? Path.GetFileName(Path.GetDirectoryName(args.Path)),
+                IsInMixedFolder = true,
+            };
         }
 
         private Book GetBook(ItemResolveArgs args)
@@ -59,15 +64,22 @@ namespace Emby.Server.Implementations.Library.Resolvers.Books
                     StringComparison.OrdinalIgnoreCase);
             }).ToList();
 
-            // Don't return a Book if there is more (or less) than one document in the directory
+            // directory is only considered a book when it contains exactly one supported file
+            // other library structures with multiple books to a directory will get picked up as individual files
             if (bookFiles.Count != 1)
             {
                 return null;
             }
 
+            var result = BookFileNameParser.Parse(Path.GetFileName(args.Path));
+
             return new Book
             {
-                Path = bookFiles[0].FullName
+                Path = bookFiles[0].FullName,
+                Name = result.Name ?? string.Empty,
+                IndexNumber = result.Index,
+                ProductionYear = result.Year,
+                SeriesName = result.SeriesName ?? string.Empty,
             };
         }
     }

Emby.Server.Implementations/Library/Resolvers/Movies/MovieResolver.cs

@@ -28,15 +28,16 @@ namespace Emby.Server.Implementations.Library.Resolvers.Movies
     public partial class MovieResolver : BaseVideoResolver<Video>, IMultiItemResolver
     {
         private readonly IImageProcessor _imageProcessor;
+        private readonly VideoListResolver _videoListResolver;
 
-        private static readonly CollectionType[] _validCollectionTypes = new[]
+        private static readonly CollectionType[] _validCollectionTypes =
-        {
+        [
             CollectionType.movies,
             CollectionType.homevideos,
             CollectionType.musicvideos,
             CollectionType.tvshows,
             CollectionType.photos
-        };
+        ];
 
         /// <summary>
         /// Initializes a new instance of the <see cref="MovieResolver"/> class.
@@ -45,10 +46,12 @@ namespace Emby.Server.Implementations.Library.Resolvers.Movies
         /// <param name="logger">The logger.</param>
         /// <param name="namingOptions">The naming options.</param>
         /// <param name="directoryService">The directory service.</param>
-        public MovieResolver(IImageProcessor imageProcessor, ILogger<MovieResolver> logger, NamingOptions namingOptions, IDirectoryService directoryService)
+        /// <param name="videoListResolver">The video list resolver.</param>
+        public MovieResolver(IImageProcessor imageProcessor, ILogger<MovieResolver> logger, NamingOptions namingOptions, IDirectoryService directoryService, VideoListResolver videoListResolver)
             : base(logger, namingOptions, directoryService)
         {
             _imageProcessor = imageProcessor;
+            _videoListResolver = videoListResolver;
         }
 
         /// <summary>
@@ -228,7 +231,7 @@ namespace Emby.Server.Implementations.Library.Resolvers.Movies
 
             if (collectionType == CollectionType.tvshows)
             {
-                return ResolveVideos<Episode>(parent, files, false, collectionType, true);
+                return ResolveVideos<Episode>(parent, files, true, collectionType, true);
             }
 
             return null;
@@ -274,7 +277,7 @@ namespace Emby.Server.Implementations.Library.Resolvers.Movies
                 .Where(f => f is not null)
                 .ToList();
 
-            var resolverResult = VideoListResolver.Resolve(videoInfos, NamingOptions, supportMultiEditions, parseName, parent.ContainingFolderPath);
+            var resolverResult = _videoListResolver.Resolve(videoInfos, supportMultiEditions, parseName, parent.ContainingFolderPath, collectionType);
 
             var result = new MultiItemResolverResult
             {
@@ -302,7 +305,7 @@ namespace Emby.Server.Implementations.Library.Resolvers.Movies
                     ProductionYear = video.Year,
                     Name = parseName ? video.Name : firstVideo.Name,
                     AdditionalParts = additionalParts,
-                    LocalAlternateVersions = video.AlternateVersions.Select(i => i.Path).ToArray()
+                    LocalAlternateVersions = video.AlternateVersions.Select(av => av.Files[0].Path).ToArray()
                 };
 
                 SetVideoType(videoItem, firstVideo);
@@ -331,9 +334,13 @@ namespace Emby.Server.Implementations.Library.Resolvers.Movies
 
                 for (var j = 0; j < current.AlternateVersions.Count; j++)
                 {
-                    if (ContainsFile(current.AlternateVersions[j], file))
+                    var alternate = current.AlternateVersions[j];
+                    for (var k = 0; k < alternate.Files.Count; k++)
                     {
-                        return true;
+                        if (ContainsFile(alternate.Files[k], file))
+                        {
+                            return true;
+                        }
                     }
                 }
             }

Emby.Server.Implementations/Library/Resolvers/TV/EpisodeResolver.cs

@@ -1,8 +1,10 @@
 #nullable disable
 
 using System;
+using System.IO;
 using System.Linq;
 using Emby.Naming.Common;
+using Emby.Server.Implementations.Library;
 using Jellyfin.Data.Enums;
 using MediaBrowser.Controller.Entities.TV;
 using MediaBrowser.Controller.Library;
@@ -81,10 +83,34 @@ namespace Emby.Server.Implementations.Library.Resolvers.TV
                     episode.ParentIndexNumber = 1;
                 }
 
+                SetProviderIdFromPath(episode, args.Path);
+
                 return episode;
             }
 
             return null;
         }
+
+        /// <summary>
+        /// Sets provider ids from the episode file name.
+        /// </summary>
+        /// <param name="item">The episode.</param>
+        /// <param name="path">The episode file path.</param>
+        private static void SetProviderIdFromPath(Episode item, string path)
+        {
+            var justName = Path.GetFileNameWithoutExtension(path.AsSpan());
+
+            var imdbId = justName.GetAttributeValue("imdbid");
+            item.TrySetProviderId(MetadataProvider.Imdb, imdbId);
+
+            var tvdbId = justName.GetAttributeValue("tvdbid");
+            item.TrySetProviderId(MetadataProvider.Tvdb, tvdbId);
+
+            var tvmazeId = justName.GetAttributeValue("tvmazeid");
+            item.TrySetProviderId(MetadataProvider.TvMaze, tvmazeId);
+
+            var tmdbId = justName.GetAttributeValue("tmdbid");
+            item.TrySetProviderId(MetadataProvider.Tmdb, tmdbId);
+        }
     }
 }

Emby.Server.Implementations/Library/Resolvers/TV/SeasonResolver.cs

@@ -1,10 +1,15 @@
 #nullable disable
 
+using System;
 using System.Globalization;
+using System.IO;
+using System.Linq;
 using Emby.Naming.Common;
 using Emby.Naming.TV;
+using Emby.Server.Implementations.Library;
 using MediaBrowser.Controller.Entities.TV;
 using MediaBrowser.Controller.Library;
+using MediaBrowser.Model.Entities;
 using MediaBrowser.Model.Globalization;
 using Microsoft.Extensions.Logging;
 
@@ -77,6 +82,14 @@ namespace Emby.Server.Implementations.Library.Resolvers.TV
 
                         return null;
                     }
+
+                    var hasAnyVideo = Directory.EnumerateFiles(path, "*", SearchOption.AllDirectories)
+                        .Any(file => _namingOptions.VideoFileExtensions.Contains(Path.GetExtension(file)));
+
+                    if (!hasAnyVideo)
+                    {
+                        return null;
+                    }
                 }
 
                 if (season.IndexNumber.HasValue && string.IsNullOrEmpty(season.Name))
@@ -91,10 +104,31 @@ namespace Emby.Server.Implementations.Library.Resolvers.TV
                             args.LibraryOptions.PreferredMetadataLanguage);
                 }
 
+                SetProviderIdFromPath(season, path);
+
                 return season;
             }
 
             return null;
         }
+
+        /// <summary>
+        /// Sets provider ids from the season folder name.
+        /// </summary>
+        /// <param name="item">The season.</param>
+        /// <param name="path">The season folder path.</param>
+        private static void SetProviderIdFromPath(Season item, string path)
+        {
+            var justName = Path.GetFileName(path.AsSpan());
+
+            var tvdbId = justName.GetAttributeValue("tvdbid");
+            item.TrySetProviderId(MetadataProvider.Tvdb, tvdbId);
+
+            var tvmazeId = justName.GetAttributeValue("tvmazeid");
+            item.TrySetProviderId(MetadataProvider.TvMaze, tvmazeId);
+
+            var tmdbId = justName.GetAttributeValue("tmdbid");
+            item.TrySetProviderId(MetadataProvider.Tmdb, tmdbId);
+        }
     }
 }

Emby.Server.Implementations/Library/SearchEngine.cs

@@ -42,7 +42,7 @@ namespace Emby.Server.Implementations.Library
                 results = results.GetRange(query.StartIndex.Value, totalRecordCount - query.StartIndex.Value);
             }
 
-            if (query.Limit.HasValue)
+            if (query.Limit.HasValue && query.Limit.Value > 0)
             {
                 results = results.GetRange(0, Math.Min(query.Limit.Value, results.Count));
             }

Emby.Server.Implementations/Library/SimilarItems/AudioSimilarItemsProvider.cs

@@ -0,0 +1,55 @@
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using Jellyfin.Data.Enums;
+using Jellyfin.Database.Implementations.Enums;
+using MediaBrowser.Controller.Dto;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Entities.Audio;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Model.Configuration;
+
+namespace Emby.Server.Implementations.Library.SimilarItems;
+
+/// <summary>
+/// Provides similar items for audio tracks.
+/// </summary>
+public class AudioSimilarItemsProvider : ILocalSimilarItemsProvider<Audio>
+{
+    private readonly ILibraryManager _libraryManager;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="AudioSimilarItemsProvider"/> class.
+    /// </summary>
+    /// <param name="libraryManager">The library manager.</param>
+    public AudioSimilarItemsProvider(ILibraryManager libraryManager)
+    {
+        _libraryManager = libraryManager;
+    }
+
+    /// <inheritdoc/>
+    public string Name => "Local Genre/Tag";
+
+    /// <inheritdoc/>
+    public MetadataPluginType Type => MetadataPluginType.LocalSimilarityProvider;
+
+    /// <inheritdoc/>
+    public Task<IReadOnlyList<BaseItem>> GetSimilarItemsAsync(Audio item, SimilarItemsQuery query, CancellationToken cancellationToken)
+    {
+        var internalQuery = new InternalItemsQuery(query.User)
+        {
+            Genres = item.Genres,
+            Tags = item.Tags,
+            Limit = query.Limit,
+            DtoOptions = query.DtoOptions ?? new DtoOptions(),
+            ExcludeItemIds = [.. query.ExcludeItemIds],
+            ExcludeArtistIds = [.. query.ExcludeArtistIds],
+            IncludeItemTypes = [BaseItemKind.Audio],
+            EnableGroupByMetadataKey = false,
+            EnableTotalRecordCount = true,
+            OrderBy = [(ItemSortBy.Random, SortOrder.Ascending)]
+        };
+
+        return Task.FromResult(_libraryManager.GetItemList(internalQuery));
+    }
+}

Emby.Server.Implementations/Library/SimilarItems/LiveTvProgramSimilarItemsProvider.cs

@@ -0,0 +1,94 @@
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using Jellyfin.Data.Enums;
+using Jellyfin.Database.Implementations.Enums;
+using MediaBrowser.Controller.Configuration;
+using MediaBrowser.Controller.Dto;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Controller.LiveTv;
+using MediaBrowser.Model.Configuration;
+
+namespace Emby.Server.Implementations.Library.SimilarItems;
+
+/// <summary>
+/// Provides similar items for Live TV programs.
+/// </summary>
+public class LiveTvProgramSimilarItemsProvider : ILocalSimilarItemsProvider<LiveTvProgram>
+{
+    private readonly ILibraryManager _libraryManager;
+    private readonly IServerConfigurationManager _serverConfigurationManager;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="LiveTvProgramSimilarItemsProvider"/> class.
+    /// </summary>
+    /// <param name="libraryManager">The library manager.</param>
+    /// <param name="serverConfigurationManager">The server configuration manager.</param>
+    public LiveTvProgramSimilarItemsProvider(
+        ILibraryManager libraryManager,
+        IServerConfigurationManager serverConfigurationManager)
+    {
+        _libraryManager = libraryManager;
+        _serverConfigurationManager = serverConfigurationManager;
+    }
+
+    /// <inheritdoc/>
+    public string Name => "Local Genre/Tag";
+
+    /// <inheritdoc/>
+    public MetadataPluginType Type => MetadataPluginType.LocalSimilarityProvider;
+
+    /// <inheritdoc/>
+    public Task<IReadOnlyList<BaseItem>> GetSimilarItemsAsync(LiveTvProgram item, SimilarItemsQuery query, CancellationToken cancellationToken)
+    {
+        BaseItemKind[] includeItemTypes;
+        bool enableGroupByMetadataKey;
+        bool enableTotalRecordCount;
+
+        if (item.IsMovie)
+        {
+            // Movie-like program
+            var itemTypes = new List<BaseItemKind> { BaseItemKind.Movie };
+
+            if (_serverConfigurationManager.Configuration.EnableExternalContentInSuggestions)
+            {
+                itemTypes.Add(BaseItemKind.Trailer);
+                itemTypes.Add(BaseItemKind.LiveTvProgram);
+            }
+
+            includeItemTypes = [.. itemTypes];
+            enableGroupByMetadataKey = true;
+            enableTotalRecordCount = false;
+        }
+        else if (item.IsSeries)
+        {
+            // Series-like program
+            includeItemTypes = [BaseItemKind.Series];
+            enableGroupByMetadataKey = false;
+            enableTotalRecordCount = true;
+        }
+        else
+        {
+            // Default - match same type
+            includeItemTypes = [item.GetBaseItemKind()];
+            enableGroupByMetadataKey = false;
+            enableTotalRecordCount = true;
+        }
+
+        var internalQuery = new InternalItemsQuery(query.User)
+        {
+            Genres = item.Genres,
+            Tags = item.Tags,
+            Limit = query.Limit,
+            DtoOptions = query.DtoOptions ?? new DtoOptions(),
+            ExcludeItemIds = [.. query.ExcludeItemIds],
+            IncludeItemTypes = includeItemTypes,
+            EnableGroupByMetadataKey = enableGroupByMetadataKey,
+            EnableTotalRecordCount = enableTotalRecordCount,
+            OrderBy = [(ItemSortBy.Random, SortOrder.Ascending)]
+        };
+
+        return Task.FromResult(_libraryManager.GetItemList(internalQuery));
+    }
+}

Emby.Server.Implementations/Library/SimilarItems/MovieSimilarItemsProvider.cs

@@ -0,0 +1,91 @@
+using System;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using Jellyfin.Data.Enums;
+using Jellyfin.Database.Implementations.Enums;
+using MediaBrowser.Controller.Configuration;
+using MediaBrowser.Controller.Dto;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Entities.Movies;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Model.Configuration;
+
+namespace Emby.Server.Implementations.Library.SimilarItems;
+
+/// <summary>
+/// Provides similar items for movies and trailers.
+/// </summary>
+public sealed class MovieSimilarItemsProvider : ILocalSimilarItemsProvider<Movie>, ILocalSimilarItemsProvider<Trailer>
+{
+    private readonly ILibraryManager _libraryManager;
+    private readonly IServerConfigurationManager _serverConfigurationManager;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="MovieSimilarItemsProvider"/> class.
+    /// </summary>
+    /// <param name="libraryManager">The library manager.</param>
+    /// <param name="serverConfigurationManager">The server configuration manager.</param>
+    public MovieSimilarItemsProvider(
+        ILibraryManager libraryManager,
+        IServerConfigurationManager serverConfigurationManager)
+    {
+        _libraryManager = libraryManager;
+        _serverConfigurationManager = serverConfigurationManager;
+    }
+
+    /// <inheritdoc/>
+    public string Name => "Local Genre/Tag";
+
+    /// <inheritdoc/>
+    public MetadataPluginType Type => MetadataPluginType.LocalSimilarityProvider;
+
+    /// <inheritdoc/>
+    public Task<IReadOnlyList<BaseItem>> GetSimilarItemsAsync(Movie item, SimilarItemsQuery query, CancellationToken cancellationToken)
+    {
+        return Task.FromResult(GetSimilarMovieItems(item, query));
+    }
+
+    /// <inheritdoc/>
+    public Task<IReadOnlyList<BaseItem>> GetSimilarItemsAsync(Trailer item, SimilarItemsQuery query, CancellationToken cancellationToken)
+    {
+        return Task.FromResult(GetSimilarMovieItems(item, query));
+    }
+
+    bool ILocalSimilarItemsProvider.Supports(Type itemType)
+        => typeof(Movie).IsAssignableFrom(itemType) || typeof(Trailer).IsAssignableFrom(itemType);
+
+    Task<IReadOnlyList<BaseItem>> ILocalSimilarItemsProvider.GetSimilarItemsAsync(BaseItem item, SimilarItemsQuery query, CancellationToken cancellationToken)
+        => item switch
+        {
+            Movie movie => GetSimilarItemsAsync(movie, query, cancellationToken),
+            Trailer trailer => GetSimilarItemsAsync(trailer, query, cancellationToken),
+            _ => throw new ArgumentException($"Unsupported item type {item.GetType()}", nameof(item))
+        };
+
+    private IReadOnlyList<BaseItem> GetSimilarMovieItems(BaseItem item, SimilarItemsQuery query)
+    {
+        var includeItemTypes = new List<BaseItemKind> { BaseItemKind.Movie };
+
+        if (_serverConfigurationManager.Configuration.EnableExternalContentInSuggestions)
+        {
+            includeItemTypes.Add(BaseItemKind.Trailer);
+            includeItemTypes.Add(BaseItemKind.LiveTvProgram);
+        }
+
+        var internalQuery = new InternalItemsQuery(query.User)
+        {
+            Genres = item.Genres,
+            Tags = item.Tags,
+            Limit = query.Limit,
+            DtoOptions = query.DtoOptions ?? new DtoOptions(),
+            ExcludeItemIds = [.. query.ExcludeItemIds],
+            IncludeItemTypes = [.. includeItemTypes],
+            EnableGroupByMetadataKey = true,
+            EnableTotalRecordCount = false,
+            OrderBy = [(ItemSortBy.Random, SortOrder.Ascending)]
+        };
+
+        return _libraryManager.GetItemList(internalQuery);
+    }
+}

Emby.Server.Implementations/Library/SimilarItems/MusicAlbumSimilarItemsProvider.cs

@@ -0,0 +1,55 @@
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using Jellyfin.Data.Enums;
+using Jellyfin.Database.Implementations.Enums;
+using MediaBrowser.Controller.Dto;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Entities.Audio;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Model.Configuration;
+
+namespace Emby.Server.Implementations.Library.SimilarItems;
+
+/// <summary>
+/// Provides similar items for music albums.
+/// </summary>
+public class MusicAlbumSimilarItemsProvider : ILocalSimilarItemsProvider<MusicAlbum>
+{
+    private readonly ILibraryManager _libraryManager;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="MusicAlbumSimilarItemsProvider"/> class.
+    /// </summary>
+    /// <param name="libraryManager">The library manager.</param>
+    public MusicAlbumSimilarItemsProvider(ILibraryManager libraryManager)
+    {
+        _libraryManager = libraryManager;
+    }
+
+    /// <inheritdoc/>
+    public string Name => "Local Genre/Tag";
+
+    /// <inheritdoc/>
+    public MetadataPluginType Type => MetadataPluginType.LocalSimilarityProvider;
+
+    /// <inheritdoc/>
+    public Task<IReadOnlyList<BaseItem>> GetSimilarItemsAsync(MusicAlbum item, SimilarItemsQuery query, CancellationToken cancellationToken)
+    {
+        var internalQuery = new InternalItemsQuery(query.User)
+        {
+            Genres = item.Genres,
+            Tags = item.Tags,
+            Limit = query.Limit,
+            DtoOptions = query.DtoOptions ?? new DtoOptions(),
+            ExcludeItemIds = [.. query.ExcludeItemIds],
+            ExcludeArtistIds = [.. query.ExcludeArtistIds],
+            IncludeItemTypes = [BaseItemKind.MusicAlbum],
+            EnableGroupByMetadataKey = false,
+            EnableTotalRecordCount = true,
+            OrderBy = [(ItemSortBy.Random, SortOrder.Ascending)]
+        };
+
+        return Task.FromResult(_libraryManager.GetItemList(internalQuery));
+    }
+}

Emby.Server.Implementations/Library/SimilarItems/MusicArtistSimilarItemsProvider.cs

@@ -0,0 +1,55 @@
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using Jellyfin.Data.Enums;
+using Jellyfin.Database.Implementations.Enums;
+using MediaBrowser.Controller.Dto;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Entities.Audio;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Model.Configuration;
+
+namespace Emby.Server.Implementations.Library.SimilarItems;
+
+/// <summary>
+/// Provides similar items for music artists.
+/// </summary>
+public class MusicArtistSimilarItemsProvider : ILocalSimilarItemsProvider<MusicArtist>
+{
+    private readonly ILibraryManager _libraryManager;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="MusicArtistSimilarItemsProvider"/> class.
+    /// </summary>
+    /// <param name="libraryManager">The library manager.</param>
+    public MusicArtistSimilarItemsProvider(ILibraryManager libraryManager)
+    {
+        _libraryManager = libraryManager;
+    }
+
+    /// <inheritdoc/>
+    public string Name => "Local Genre/Tag";
+
+    /// <inheritdoc/>
+    public MetadataPluginType Type => MetadataPluginType.LocalSimilarityProvider;
+
+    /// <inheritdoc/>
+    public Task<IReadOnlyList<BaseItem>> GetSimilarItemsAsync(MusicArtist item, SimilarItemsQuery query, CancellationToken cancellationToken)
+    {
+        var internalQuery = new InternalItemsQuery(query.User)
+        {
+            Genres = item.Genres,
+            Tags = item.Tags,
+            Limit = query.Limit,
+            DtoOptions = query.DtoOptions ?? new DtoOptions(),
+            ExcludeItemIds = [.. query.ExcludeItemIds],
+            ExcludeArtistIds = [.. query.ExcludeArtistIds],
+            IncludeItemTypes = [BaseItemKind.MusicArtist],
+            EnableGroupByMetadataKey = false,
+            EnableTotalRecordCount = true,
+            OrderBy = [(ItemSortBy.Random, SortOrder.Ascending)]
+        };
+
+        return Task.FromResult(_libraryManager.GetItemList(internalQuery));
+    }
+}

Emby.Server.Implementations/Library/SimilarItems/SeriesSimilarItemsProvider.cs

@@ -0,0 +1,54 @@
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using Jellyfin.Data.Enums;
+using Jellyfin.Database.Implementations.Enums;
+using MediaBrowser.Controller.Dto;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Entities.TV;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Model.Configuration;
+
+namespace Emby.Server.Implementations.Library.SimilarItems;
+
+/// <summary>
+/// Provides similar items for TV series.
+/// </summary>
+public class SeriesSimilarItemsProvider : ILocalSimilarItemsProvider<Series>
+{
+    private readonly ILibraryManager _libraryManager;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="SeriesSimilarItemsProvider"/> class.
+    /// </summary>
+    /// <param name="libraryManager">The library manager.</param>
+    public SeriesSimilarItemsProvider(ILibraryManager libraryManager)
+    {
+        _libraryManager = libraryManager;
+    }
+
+    /// <inheritdoc/>
+    public string Name => "Local Genre/Tag";
+
+    /// <inheritdoc/>
+    public MetadataPluginType Type => MetadataPluginType.LocalSimilarityProvider;
+
+    /// <inheritdoc/>
+    public Task<IReadOnlyList<BaseItem>> GetSimilarItemsAsync(Series item, SimilarItemsQuery query, CancellationToken cancellationToken)
+    {
+        var internalQuery = new InternalItemsQuery(query.User)
+        {
+            Genres = item.Genres,
+            Tags = item.Tags,
+            Limit = query.Limit,
+            DtoOptions = query.DtoOptions ?? new DtoOptions(),
+            ExcludeItemIds = [.. query.ExcludeItemIds],
+            IncludeItemTypes = [BaseItemKind.Series],
+            EnableGroupByMetadataKey = false,
+            EnableTotalRecordCount = true,
+            OrderBy = [(ItemSortBy.Random, SortOrder.Ascending)]
+        };
+
+        return Task.FromResult(_libraryManager.GetItemList(internalQuery));
+    }
+}

Emby.Server.Implementations/Library/SimilarItems/SimilarItemsManager.cs

@@ -0,0 +1,406 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Text.Json;
+using System.Threading;
+using System.Threading.Tasks;
+using Jellyfin.Data.Enums;
+using Jellyfin.Database.Implementations.Entities;
+using Jellyfin.Extensions.Json;
+using MediaBrowser.Controller;
+using MediaBrowser.Controller.Dto;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Model.Configuration;
+using MediaBrowser.Model.Entities;
+using MediaBrowser.Model.IO;
+using MediaBrowser.Model.Querying;
+using Microsoft.Extensions.Logging;
+
+namespace Emby.Server.Implementations.Library.SimilarItems;
+
+/// <summary>
+/// Manages similar items providers and orchestrates similar items operations.
+/// </summary>
+public class SimilarItemsManager : ISimilarItemsManager
+{
+    private readonly ILogger<SimilarItemsManager> _logger;
+    private readonly IServerApplicationPaths _appPaths;
+    private readonly ILibraryManager _libraryManager;
+    private readonly IFileSystem _fileSystem;
+    private ISimilarItemsProvider[] _similarItemsProviders = [];
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="SimilarItemsManager"/> class.
+    /// </summary>
+    /// <param name="logger">The logger.</param>
+    /// <param name="appPaths">The server application paths.</param>
+    /// <param name="libraryManager">The library manager.</param>
+    /// <param name="fileSystem">The file system.</param>
+    public SimilarItemsManager(
+        ILogger<SimilarItemsManager> logger,
+        IServerApplicationPaths appPaths,
+        ILibraryManager libraryManager,
+        IFileSystem fileSystem)
+    {
+        _logger = logger;
+        _appPaths = appPaths;
+        _libraryManager = libraryManager;
+        _fileSystem = fileSystem;
+    }
+
+    /// <inheritdoc/>
+    public void AddParts(IEnumerable<ISimilarItemsProvider> providers)
+    {
+        _similarItemsProviders = providers.ToArray();
+    }
+
+    /// <inheritdoc/>
+    public IReadOnlyList<ISimilarItemsProvider> GetSimilarItemsProviders<T>()
+        where T : BaseItem
+    {
+        var itemType = typeof(T);
+        return _similarItemsProviders
+            .Where(p => (p is ILocalSimilarItemsProvider local && local.Supports(itemType))
+                || (p is IRemoteSimilarItemsProvider remote && remote.Supports(itemType)))
+            .ToList();
+    }
+
+    /// <inheritdoc/>
+    public async Task<IReadOnlyList<BaseItem>> GetSimilarItemsAsync(
+        BaseItem item,
+        IReadOnlyList<Guid> excludeArtistIds,
+        User? user,
+        DtoOptions dtoOptions,
+        int? limit,
+        LibraryOptions? libraryOptions,
+        CancellationToken cancellationToken)
+    {
+        ArgumentNullException.ThrowIfNull(item);
+        ArgumentNullException.ThrowIfNull(excludeArtistIds);
+
+        var itemType = item.GetType();
+        var requestedLimit = limit ?? 50;
+        var itemKind = item.GetBaseItemKind();
+
+        // Ensure ProviderIds is included in DtoOptions for matching remote provider responses
+        if (!dtoOptions.Fields.Contains(ItemFields.ProviderIds))
+        {
+            dtoOptions.Fields = dtoOptions.Fields.Concat([ItemFields.ProviderIds]).ToArray();
+        }
+
+        // Local providers are always enabled. Remote providers must be explicitly enabled.
+        var localProviders = _similarItemsProviders
+            .OfType<ILocalSimilarItemsProvider>()
+            .Where(p => p.Supports(itemType))
+            .ToList();
+        var remoteProviders = _similarItemsProviders
+            .OfType<IRemoteSimilarItemsProvider>()
+            .Where(p => p.Supports(itemType));
+        var matchingProviders = new List<ISimilarItemsProvider>(localProviders);
+
+        var typeOptions = libraryOptions?.GetTypeOptions(itemType.Name);
+        if (typeOptions?.SimilarItemProviders?.Length > 0)
+        {
+            matchingProviders.AddRange(remoteProviders
+                .Where(p => typeOptions.SimilarItemProviders.Contains(p.Name, StringComparer.OrdinalIgnoreCase)));
+        }
+
+        var orderConfig = typeOptions?.SimilarItemProviderOrder is { Length: > 0 } order
+            ? order
+            : typeOptions?.SimilarItemProviders;
+        var orderedProviders = matchingProviders
+            .OrderBy(p => GetConfiguredSimilarProviderOrder(orderConfig, p.Name))
+            .ToList();
+
+        var allResults = new List<(BaseItem Item, float Score)>();
+        var excludeIds = new HashSet<Guid> { item.Id };
+        foreach (var (providerOrder, provider) in orderedProviders.Index())
+        {
+            if (allResults.Count >= requestedLimit || cancellationToken.IsCancellationRequested)
+            {
+                break;
+            }
+
+            try
+            {
+                if (provider is ILocalSimilarItemsProvider localProvider)
+                {
+                    var query = new SimilarItemsQuery
+                    {
+                        User = user,
+                        Limit = requestedLimit - allResults.Count,
+                        DtoOptions = dtoOptions,
+                        ExcludeItemIds = [.. excludeIds],
+                        ExcludeArtistIds = excludeArtistIds
+                    };
+
+                    var items = await localProvider.GetSimilarItemsAsync(item, query, cancellationToken).ConfigureAwait(false);
+
+                    foreach (var (position, resultItem) in items.Index())
+                    {
+                        if (excludeIds.Add(resultItem.Id))
+                        {
+                            var score = CalculateScore(null, providerOrder, position);
+                            allResults.Add((resultItem, score));
+                        }
+                    }
+                }
+                else if (provider is IRemoteSimilarItemsProvider remoteProvider)
+                {
+                    var cachePath = GetSimilarItemsCachePath(provider.Name, itemType.Name, item.Id);
+
+                    var cachedReferences = await TryReadSimilarItemsCacheAsync(cachePath, cancellationToken).ConfigureAwait(false);
+                    if (cachedReferences is not null)
+                    {
+                        var resolvedItems = ResolveRemoteReferences(cachedReferences, providerOrder, user, dtoOptions, itemKind, excludeIds);
+                        allResults.AddRange(resolvedItems);
+                        continue;
+                    }
+
+                    var query = new SimilarItemsQuery
+                    {
+                        User = user,
+                        Limit = requestedLimit - allResults.Count,
+                        DtoOptions = dtoOptions,
+                        ExcludeItemIds = [.. excludeIds],
+                        ExcludeArtistIds = excludeArtistIds
+                    };
+
+                    // Collect references in batches and resolve against local library.
+                    // Stop fetching once we have enough resolved local items.
+                    const int BatchSize = 20;
+                    var remaining = requestedLimit - allResults.Count;
+                    var collectedReferences = new List<SimilarItemReference>();
+                    var pendingBatch = new List<SimilarItemReference>();
+
+                    await foreach (var reference in remoteProvider.GetSimilarItemsAsync(item, query, cancellationToken).ConfigureAwait(false))
+                    {
+                        collectedReferences.Add(reference);
+                        pendingBatch.Add(reference);
+
+                        if (pendingBatch.Count >= BatchSize)
+                        {
+                            var resolvedItems = ResolveRemoteReferences(pendingBatch, providerOrder, user, dtoOptions, itemKind, excludeIds);
+                            allResults.AddRange(resolvedItems);
+                            remaining -= resolvedItems.Count;
+                            pendingBatch.Clear();
+
+                            if (remaining <= 0)
+                            {
+                                break;
+                            }
+                        }
+                    }
+
+                    // Resolve any remaining references in the last partial batch
+                    if (pendingBatch.Count > 0)
+                    {
+                        var resolvedItems = ResolveRemoteReferences(pendingBatch, providerOrder, user, dtoOptions, itemKind, excludeIds);
+                        allResults.AddRange(resolvedItems);
+                    }
+
+                    if (collectedReferences.Count > 0 && provider.CacheDuration is not null)
+                    {
+                        await SaveSimilarItemsCacheAsync(cachePath, collectedReferences, provider.CacheDuration.Value, cancellationToken).ConfigureAwait(false);
+                    }
+                }
+            }
+            catch (OperationCanceledException)
+            {
+                break;
+            }
+            catch (Exception ex)
+            {
+                _logger.LogWarning(ex, "Similar items provider {ProviderName} failed for item {ItemId}", provider.Name, item.Id);
+            }
+        }
+
+        return allResults
+            .OrderByDescending(x => x.Score)
+            .Select(x => x.Item)
+            .Take(requestedLimit)
+            .ToList();
+    }
+
+    private List<(BaseItem Item, float Score)> ResolveRemoteReferences(
+        IReadOnlyList<SimilarItemReference> references,
+        int providerOrder,
+        User? user,
+        DtoOptions dtoOptions,
+        BaseItemKind itemKind,
+        HashSet<Guid> excludeIds)
+    {
+        if (references.Count == 0)
+        {
+            return [];
+        }
+
+        var resolvedById = new Dictionary<Guid, (BaseItem Item, float Score)>();
+        var providerLookup = new Dictionary<(string ProviderName, string ProviderId), (float? Score, int Position)>(StringTupleComparer.Instance);
+
+        foreach (var (position, match) in references.Index())
+        {
+            var lookupKey = (match.ProviderName, match.ProviderId);
+            if (!providerLookup.TryGetValue(lookupKey, out var existing))
+            {
+                providerLookup[lookupKey] = (match.Score, position);
+            }
+            else if (match.Score > existing.Score || (match.Score == existing.Score && position < existing.Position))
+            {
+                providerLookup[lookupKey] = (match.Score, position);
+            }
+        }
+
+        var allProviderIds = providerLookup
+            .GroupBy(kvp => kvp.Key.ProviderName)
+            .ToDictionary(g => g.Key, g => g.Select(x => x.Key.ProviderId).ToArray());
+
+        var query = new InternalItemsQuery(user)
+        {
+            HasAnyProviderIds = allProviderIds,
+            IncludeItemTypes = [itemKind],
+            DtoOptions = dtoOptions
+        };
+
+        var items = _libraryManager.GetItemList(query);
+
+        foreach (var item in items)
+        {
+            if (excludeIds.Contains(item.Id) || resolvedById.ContainsKey(item.Id))
+            {
+                continue;
+            }
+
+            foreach (var providerName in allProviderIds.Keys)
+            {
+                if (item.TryGetProviderId(providerName, out var itemProviderId) && providerLookup.TryGetValue((providerName, itemProviderId), out var matchInfo))
+                {
+                    var score = CalculateScore(matchInfo.Score, providerOrder, matchInfo.Position);
+                    if (!resolvedById.TryGetValue(item.Id, out var existing) || existing.Score < score)
+                    {
+                        excludeIds.Add(item.Id);
+                        resolvedById[item.Id] = (item, score);
+                    }
+
+                    break;
+                }
+            }
+        }
+
+        return [.. resolvedById.Values];
+    }
+
+    private static float CalculateScore(float? matchScore, int providerOrder, int position)
+    {
+        // Use provider-supplied score if available, otherwise derive from position
+        var baseScore = matchScore ?? (1.0f - (position * 0.02f));
+
+        // Apply small boost based on provider order (higher priority providers get small bonus)
+        var priorityBoost = Math.Max(0, 10 - providerOrder) * 0.005f;
+
+        return Math.Clamp(baseScore + priorityBoost, 0f, 1f);
+    }
+
+    private static int GetConfiguredSimilarProviderOrder(string[]? orderConfig, string providerName)
+    {
+        if (orderConfig is null || orderConfig.Length == 0)
+        {
+            return int.MaxValue;
+        }
+
+        var index = Array.FindIndex(orderConfig, name => string.Equals(name, providerName, StringComparison.OrdinalIgnoreCase));
+        return index >= 0 ? index : int.MaxValue;
+    }
+
+    private string GetSimilarItemsCachePath(string providerName, string baseItemType, Guid itemId)
+    {
+        var dataPath = Path.Combine(
+            _appPaths.CachePath,
+            $"{providerName.ToLowerInvariant()}-similar-{baseItemType.ToLowerInvariant()}");
+        return Path.Combine(dataPath, $"{itemId.ToString("N", CultureInfo.InvariantCulture)}.json");
+    }
+
+    private async Task<List<SimilarItemReference>?> TryReadSimilarItemsCacheAsync(string cachePath, CancellationToken cancellationToken)
+    {
+        var fileInfo = _fileSystem.GetFileSystemInfo(cachePath);
+        if (!fileInfo.Exists || fileInfo.Length == 0)
+        {
+            return null;
+        }
+
+        try
+        {
+            var stream = File.OpenRead(cachePath);
+            await using (stream.ConfigureAwait(false))
+            {
+                var cache = await JsonSerializer.DeserializeAsync<SimilarItemsCache>(stream, JsonDefaults.Options, cancellationToken).ConfigureAwait(false);
+                if (cache?.References is not null && DateTime.UtcNow < cache.ExpiresAt)
+                {
+                    return cache.References;
+                }
+            }
+        }
+        catch (IOException ex)
+        {
+            _logger.LogWarning(ex, "Failed to read similar items cache from {CachePath}", cachePath);
+        }
+        catch (JsonException ex)
+        {
+            _logger.LogWarning(ex, "Failed to parse similar items cache from {CachePath}", cachePath);
+        }
+
+        return null;
+    }
+
+    private async Task SaveSimilarItemsCacheAsync(string cachePath, List<SimilarItemReference> references, TimeSpan cacheDuration, CancellationToken cancellationToken)
+    {
+        try
+        {
+            var directory = Path.GetDirectoryName(cachePath);
+            if (!string.IsNullOrEmpty(directory))
+            {
+                Directory.CreateDirectory(directory);
+            }
+
+            var cache = new SimilarItemsCache
+            {
+                References = references,
+                ExpiresAt = DateTime.UtcNow.Add(cacheDuration)
+            };
+
+            var stream = File.Create(cachePath);
+            await using (stream.ConfigureAwait(false))
+            {
+                await JsonSerializer.SerializeAsync(stream, cache, JsonDefaults.Options, cancellationToken).ConfigureAwait(false);
+            }
+        }
+        catch (IOException ex)
+        {
+            _logger.LogWarning(ex, "Failed to save similar items cache to {CachePath}", cachePath);
+        }
+    }
+
+    private sealed class SimilarItemsCache
+    {
+        public List<SimilarItemReference>? References { get; set; }
+
+        public DateTime ExpiresAt { get; set; }
+    }
+
+    private sealed class StringTupleComparer : IEqualityComparer<(string Key, string Value)>
+    {
+        public static readonly StringTupleComparer Instance = new();
+
+        public bool Equals((string Key, string Value) x, (string Key, string Value) y)
+            => string.Equals(x.Key, y.Key, StringComparison.OrdinalIgnoreCase) &&
+               string.Equals(x.Value, y.Value, StringComparison.OrdinalIgnoreCase);
+
+        public int GetHashCode((string Key, string Value) obj)
+            => HashCode.Combine(
+                StringComparer.OrdinalIgnoreCase.GetHashCode(obj.Key),
+                StringComparer.OrdinalIgnoreCase.GetHashCode(obj.Value));
+    }
+}

Emby.Server.Implementations/Library/SplashscreenPostScanTask.cs

@@ -80,7 +80,7 @@ public class SplashscreenPostScanTask : ILibraryPostScanTask
             ImageTypes = [imageType],
             Limit = 30,
             // TODO max parental rating configurable
-            MaxParentalRating = new(10, null),
+            MaxParentalRating = new(13, null),
             OrderBy =
             [
                 (ItemSortBy.Random, SortOrder.Ascending)

Emby.Server.Implementations/Library/UserDataManager.cs

@@ -177,53 +177,74 @@ namespace Emby.Server.Implementations.Library
             };
         }
 
-        private UserItemData? GetUserData(User user, Guid itemId, List<string> keys)
+        /// <inheritdoc />
+        public Dictionary<Guid, UserItemData> GetUserDataBatch(IReadOnlyList<BaseItem> items, User user)
         {
-            var cacheKey = GetCacheKey(user.InternalId, itemId);
+            var result = new Dictionary<Guid, UserItemData>(items.Count);
+            var itemsNeedingQuery = new List<(BaseItem Item, List<string> Keys)>();
 
-            if (_cache.TryGet(cacheKey, out var data))
+            foreach (var item in items)
             {
-                return data;
+                var cacheKey = GetCacheKey(user.InternalId, item.Id);
-            }
+                if (_cache.TryGet(cacheKey, out var cachedData))
-
-            data = GetUserDataInternal(user.Id, itemId, keys);
-
-            if (data is null)
-            {
-                return new UserItemData()
                 {
-                    Key = keys[0],
+                    result[item.Id] = cachedData;
-                };
+                }
-            }
+                else
-
+                {
-            return _cache.GetOrAdd(cacheKey, _ => data);
+                    var userData = item.UserData?.Where(e => e.UserId.Equals(user.Id)).Select(Map).FirstOrDefault();
-        }
+                    if (userData is not null)
-
+                    {
-        private UserItemData? GetUserDataInternal(Guid userId, Guid itemId, List<string> keys)
+                        result[item.Id] = userData;
-        {
+                        _cache.AddOrUpdate(cacheKey, userData);
-            if (keys.Count == 0)
+                    }
-            {
+                    else
-                return null;
+                    {
-            }
+                        var keys = item.GetUserDataKeys();
-
+                        itemsNeedingQuery.Add((item, keys));
-            using var context = _repository.CreateDbContext();
+                    }
-            var userData = context.UserData.AsNoTracking().Where(e => e.ItemId == itemId && keys.Contains(e.CustomDataKey) && e.UserId.Equals(userId)).ToArray();
-
-            if (userData.Length > 0)
-            {
-                var directDataReference = userData.FirstOrDefault(e => e.CustomDataKey == itemId.ToString("N"));
-                if (directDataReference is not null)
-                {
-                    return Map(directDataReference);
                 }
-
-                return Map(userData.First());
             }
 
-            return new UserItemData
+            if (itemsNeedingQuery.Count == 0)
             {
-                Key = keys.Last()!
+                return result;
-            };
+            }
+
+            // Build a single query for all missing items
+            var allItemIds = itemsNeedingQuery.Select(x => x.Item.Id).ToList();
+            var allKeys = itemsNeedingQuery.SelectMany(x => x.Keys).Distinct().ToList();
+            if (allKeys.Count > 0)
+            {
+                using var context = _repository.CreateDbContext();
+                var userDataArray = context.UserData
+                    .AsNoTracking()
+                    .Where(e => e.UserId.Equals(user.Id))
+                    .WhereOneOrMany(allItemIds, e => e.ItemId)
+                    .WhereOneOrMany(allKeys, e => e.CustomDataKey)
+                    .ToArray();
+
+                var userDataByItem = userDataArray.GroupBy(e => e.ItemId).ToDictionary(g => g.Key, g => g.ToArray());
+                foreach (var (item, keys) in itemsNeedingQuery)
+                {
+                    UserItemData userData;
+                    if (userDataByItem.TryGetValue(item.Id, out var itemUserData) && itemUserData.Length > 0)
+                    {
+                        var directDataReference = itemUserData.FirstOrDefault(e => e.CustomDataKey == item.Id.ToString("N"));
+                        userData = directDataReference is not null ? Map(directDataReference) : Map(itemUserData.First());
+                    }
+                    else
+                    {
+                        userData = new UserItemData { Key = keys.Count > 0 ? keys[0] : string.Empty };
+                    }
+
+                    result[item.Id] = userData;
+                    var cacheKey = GetCacheKey(user.InternalId, item.Id);
+                    _cache.AddOrUpdate(cacheKey, userData);
+                }
+            }
+
+            return result;
         }
 
         /// <summary>

Emby.Server.Implementations/Library/UserViewManager.cs

@@ -59,8 +59,8 @@ namespace Emby.Server.Implementations.Library
                 var collectionFolder = folder as ICollectionFolder;
                 var folderViewType = collectionFolder?.CollectionType;
 
-                // Playlist library requires special handling because the folder only references user playlists
+                // Playlist and BoxSet libraries require special handling because the folder only references linked items
-                if (folderViewType == CollectionType.playlists)
+                if (folderViewType == CollectionType.playlists || folderViewType == CollectionType.boxsets)
                 {
                     var items = folder.GetItemList(new InternalItemsQuery(user)
                     {
@@ -138,7 +138,7 @@ namespace Emby.Server.Implementations.Library
                 list = list.Where(i => !user.GetPreferenceValues<Guid>(PreferenceKind.MyMediaExcludes).Contains(i.Id)).ToList();
             }
 
-            var sorted = _libraryManager.Sort(list, user, new[] { ItemSortBy.SortName }, SortOrder.Ascending).ToList();
+            var sorted = _libraryManager.Sort(list, user, [ItemSortBy.SortName], SortOrder.Ascending).ToList();
             var orders = user.GetPreferenceValues<Guid>(PreferenceKind.OrderedViews);
 
             return list
@@ -205,7 +205,7 @@ namespace Emby.Server.Implementations.Library
             var libraryItems = GetItemsForLatestItems(request.User, request, options);
 
             var list = new List<Tuple<BaseItem, List<BaseItem>>>();
-
+            var containerIndexMap = new Dictionary<Guid, int>();
             foreach (var item in libraryItems)
             {
                 // Only grab the index container for media
@@ -213,20 +213,16 @@ namespace Emby.Server.Implementations.Library
 
                 if (container is null)
                 {
-                    list.Add(new Tuple<BaseItem, List<BaseItem>>(null, new List<BaseItem> { item }));
+                    list.Add(new Tuple<BaseItem, List<BaseItem>>(null!, new List<BaseItem> { item }));
+                }
+                else if (containerIndexMap.TryGetValue(container.Id, out var existingIndex))
+                {
+                    list[existingIndex].Item2.Add(item);
                 }
                 else
                 {
-                    var current = list.FirstOrDefault(i => i.Item1 is not null && i.Item1.Id.Equals(container.Id));
+                    containerIndexMap[container.Id] = list.Count;
-
+                    list.Add(new Tuple<BaseItem, List<BaseItem>>(container, new List<BaseItem> { item }));
-                    if (current is not null)
-                    {
-                        current.Item2.Add(item);
-                    }
-                    else
-                    {
-                        list.Add(new Tuple<BaseItem, List<BaseItem>>(container, new List<BaseItem> { item }));
-                    }
                 }
 
                 if (list.Count >= request.Limit)
@@ -255,7 +251,7 @@ namespace Emby.Server.Implementations.Library
                     return _channelManager.GetLatestChannelItemsInternal(
                         new InternalItemsQuery(user)
                         {
-                            ChannelIds = new[] { parentId },
+                            ChannelIds = [parentId],
                             IsPlayed = request.IsPlayed,
                             StartIndex = request.StartIndex,
                             Limit = request.Limit,
@@ -301,11 +297,11 @@ namespace Emby.Server.Implementations.Library
                 {
                     if (hasCollectionType.All(i => i.CollectionType == CollectionType.movies))
                     {
-                        includeItemTypes = new[] { BaseItemKind.Movie };
+                        includeItemTypes = [BaseItemKind.Movie];
                     }
                     else if (hasCollectionType.All(i => i.CollectionType == CollectionType.tvshows))
                     {
-                        includeItemTypes = new[] { BaseItemKind.Episode };
+                        includeItemTypes = [BaseItemKind.Episode];
                     }
                 }
             }
@@ -344,29 +340,29 @@ namespace Emby.Server.Implementations.Library
             }
 
             var excludeItemTypes = includeItemTypes.Length == 0 && mediaTypes.Length == 0
-                ? new[]
+                ?
-                {
+                [
                     BaseItemKind.Person,
                     BaseItemKind.Studio,
                     BaseItemKind.Year,
                     BaseItemKind.MusicGenre,
                     BaseItemKind.Genre
-                }
+                ]
                 : Array.Empty<BaseItemKind>();
 
             var query = new InternalItemsQuery(user)
             {
                 IncludeItemTypes = includeItemTypes,
-                OrderBy = new[]
+                OrderBy =
-                {
+                [
                     (ItemSortBy.DateCreated, SortOrder.Descending),
                     (ItemSortBy.SortName, SortOrder.Descending),
                     (ItemSortBy.ProductionYear, SortOrder.Descending)
-                },
+                ],
                 IsFolder = includeItemTypes.Length == 0 ? false : null,
                 ExcludeItemTypes = excludeItemTypes,
                 IsVirtualItem = false,
-                Limit = limit * 5,
+                Limit = limit * 2,
                 IsPlayed = isPlayed,
                 DtoOptions = options,
                 MediaTypes = mediaTypes
@@ -394,6 +390,12 @@ namespace Emby.Server.Implementations.Library
                     query.Limit = limit;
                     return _libraryManager.GetLatestItemList(query, parents, CollectionType.music);
                 }
+
+                if (collectionType == CollectionType.movies)
+                {
+                    query.Limit = limit;
+                    return _libraryManager.GetLatestItemList(query, parents, CollectionType.movies);
+                }
             }
 
             return _libraryManager.GetItemList(query, parents);

Emby.Server.Implementations/Library/Validators/ArtistsValidator.cs

@@ -50,21 +50,40 @@ public class ArtistsValidator
     public async Task Run(IProgress<double> progress, CancellationToken cancellationToken)
     {
         var names = _itemRepo.GetAllArtistNames();
+        var existingArtistIds = _libraryManager.GetItemIds(new InternalItemsQuery
+        {
+            IncludeItemTypes = [BaseItemKind.MusicArtist]
+        }).ToHashSet();
+
+        var existingArtists = _libraryManager.GetArtists(names);
 
         var numComplete = 0;
         var count = names.Count;
+        var refreshed = 0;
 
         foreach (var name in names)
         {
             try
             {
-                var item = _libraryManager.GetArtist(name);
+                MusicArtist? item = null;
+                if (existingArtists.TryGetValue(name, out var artists) && artists.Length > 0)
+                {
+                    item = artists.OrderBy(i => i.IsAccessedByName ? 1 : 0).First();
+                }
 
-                await item.RefreshMetadata(cancellationToken).ConfigureAwait(false);
+                // Fall back to GetArtist if not found (creates new item if needed)
+                item ??= _libraryManager.GetArtist(name);
+                var isNew = !existingArtistIds.Contains(item.Id);
+                var neverRefreshed = item.DateLastRefreshed == default;
+
+                if (isNew || neverRefreshed)
+                {
+                    await item.RefreshMetadata(cancellationToken).ConfigureAwait(false);
+                    refreshed++;
+                }
             }
             catch (OperationCanceledException)
             {
-                // Don't clutter the log
                 throw;
             }
             catch (Exception ex)
@@ -80,31 +99,24 @@ public class ArtistsValidator
             progress.Report(percent);
         }
 
+        _logger.LogInformation("Refreshed metadata for {RefreshedCount} new artists out of {TotalCount} total", refreshed, count);
+
         var deadEntities = _libraryManager.GetItemList(new InternalItemsQuery
         {
             IncludeItemTypes = [BaseItemKind.MusicArtist],
             IsDeadArtist = true,
             IsLocked = false
-        }).Cast<MusicArtist>().ToList();
+        }).Cast<MusicArtist>()
+        .Where(item => item.IsAccessedByName)
+        .ToList();
 
         foreach (var item in deadEntities)
         {
-            if (!item.IsAccessedByName)
-            {
-                continue;
-            }
-
             _logger.LogInformation("Deleting dead {ItemType} {ItemId} {ItemName}", item.GetType().Name, item.Id.ToString("N", CultureInfo.InvariantCulture), item.Name);
-
-            _libraryManager.DeleteItem(
-                item,
-                new DeleteOptions
-                {
-                    DeleteFileLocation = false
-                },
-                false);
         }
 
+        _libraryManager.DeleteItemsUnsafeFast(deadEntities, deleteSourceFiles: true);
+
         progress.Report(100);
     }
 }

Emby.Server.Implementations/Library/Validators/CollectionPostScanTask.cs

@@ -74,7 +74,7 @@ public class CollectionPostScanTask : ILibraryPostScanTask
 
                 foreach (var m in movies)
                 {
-                    if (m is Movie movie && !string.IsNullOrEmpty(movie.CollectionName))
+                    if (m is Movie movie && !string.IsNullOrEmpty(movie.CollectionName) && !movie.PrimaryVersionId.HasValue)
                     {
                         if (collectionNameMoviesMap.TryGetValue(movie.CollectionName, out var movieList))
                         {

Emby.Server.Implementations/Library/Validators/GenresValidator.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Globalization;
+using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using Jellyfin.Data.Enums;
@@ -48,17 +49,40 @@ public class GenresValidator
     public async Task Run(IProgress<double> progress, CancellationToken cancellationToken)
     {
         var names = _itemRepo.GetGenreNames();
+        var existingGenreIds = _libraryManager.GetItemIds(new InternalItemsQuery
+        {
+            IncludeItemTypes = [BaseItemKind.Genre]
+        }).ToHashSet();
+
+        var existingGenres = _libraryManager.GetItemList(new InternalItemsQuery
+        {
+            IncludeItemTypes = [BaseItemKind.Genre]
+        }).Cast<Genre>()
+        .GroupBy(g => g.Name, StringComparer.OrdinalIgnoreCase)
+        .ToDictionary(g => g.Key, g => g.First(), StringComparer.OrdinalIgnoreCase);
 
         var numComplete = 0;
         var count = names.Count;
+        var refreshed = 0;
 
         foreach (var name in names)
         {
             try
             {
-                var item = _libraryManager.GetGenre(name);
+                Genre? item = null;
+                if (existingGenres.TryGetValue(name, out var existingGenre))
+                {
+                    item = existingGenre;
+                }
 
-                await item.RefreshMetadata(cancellationToken).ConfigureAwait(false);
+                // Fall back to GetGenre if not found (creates new item if needed)
+                item ??= _libraryManager.GetGenre(name);
+
+                if (!existingGenreIds.Contains(item.Id))
+                {
+                    await item.RefreshMetadata(cancellationToken).ConfigureAwait(false);
+                    refreshed++;
+                }
             }
             catch (OperationCanceledException)
             {
@@ -78,6 +102,8 @@ public class GenresValidator
             progress.Report(percent);
         }
 
+        _logger.LogInformation("Refreshed metadata for {RefreshedCount} new genres out of {TotalCount} total", refreshed, count);
+
         var deadEntities = _libraryManager.GetItemList(new InternalItemsQuery
         {
             IncludeItemTypes = [BaseItemKind.Genre, BaseItemKind.MusicGenre],
@@ -88,16 +114,10 @@ public class GenresValidator
         foreach (var item in deadEntities)
         {
             _logger.LogInformation("Deleting dead {ItemType} {ItemId} {ItemName}", item.GetType().Name, item.Id.ToString("N", CultureInfo.InvariantCulture), item.Name);
-
-            _libraryManager.DeleteItem(
-                item,
-                new DeleteOptions
-                {
-                    DeleteFileLocation = false
-                },
-                false);
         }
 
+        _libraryManager.DeleteItemsUnsafeFast(deadEntities, deleteSourceFiles: true);
+
         progress.Report(100);
     }
 }

Emby.Server.Implementations/Library/Validators/MusicGenresValidator.cs

@@ -1,6 +1,9 @@
 using System;
+using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
+using Jellyfin.Data.Enums;
+using MediaBrowser.Controller.Entities;
 using MediaBrowser.Controller.Library;
 using MediaBrowser.Controller.Persistence;
 using Microsoft.Extensions.Logging;
@@ -45,17 +48,25 @@ public class MusicGenresValidator
     public async Task Run(IProgress<double> progress, CancellationToken cancellationToken)
     {
         var names = _itemRepo.GetMusicGenreNames();
+        var existingMusicGenreIds = _libraryManager.GetItemIds(new InternalItemsQuery
+        {
+            IncludeItemTypes = [BaseItemKind.MusicGenre]
+        }).ToHashSet();
 
         var numComplete = 0;
         var count = names.Count;
+        var refreshed = 0;
 
         foreach (var name in names)
         {
             try
             {
                 var item = _libraryManager.GetMusicGenre(name);
-
+                if (!existingMusicGenreIds.Contains(item.Id))
-                await item.RefreshMetadata(cancellationToken).ConfigureAwait(false);
+                {
+                    await item.RefreshMetadata(cancellationToken).ConfigureAwait(false);
+                    refreshed++;
+                }
             }
             catch (OperationCanceledException)
             {
@@ -75,6 +86,8 @@ public class MusicGenresValidator
             progress.Report(percent);
         }
 
+        _logger.LogInformation("Refreshed metadata for {RefreshedCount} new music genres out of {TotalCount} total", refreshed, count);
+
         progress.Report(100);
     }
 }

Emby.Server.Implementations/Library/Validators/PeopleValidator.cs

@@ -109,7 +109,7 @@ public class PeopleValidator
         var i = 0;
         foreach (var item in deadEntities.Chunk(500))
         {
-            _libraryManager.DeleteItemsUnsafeFast(item);
+            _libraryManager.DeleteItemsUnsafeFast(item, true);
             subProgress.Report(100f / deadEntities.Count * (i++ * 100));
         }
 

Emby.Server.Implementations/Library/Validators/StudiosValidator.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Globalization;
+using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using Jellyfin.Data.Enums;
@@ -49,17 +50,40 @@ public class StudiosValidator
     public async Task Run(IProgress<double> progress, CancellationToken cancellationToken)
     {
         var names = _itemRepo.GetStudioNames();
+        var existingStudioIds = _libraryManager.GetItemIds(new InternalItemsQuery
+        {
+            IncludeItemTypes = [BaseItemKind.Studio]
+        }).ToHashSet();
+
+        var existingStudios = _libraryManager.GetItemList(new InternalItemsQuery
+        {
+            IncludeItemTypes = [BaseItemKind.Studio]
+        }).Cast<Studio>()
+        .GroupBy(s => s.Name, StringComparer.OrdinalIgnoreCase)
+        .ToDictionary(g => g.Key, g => g.First(), StringComparer.OrdinalIgnoreCase);
 
         var numComplete = 0;
         var count = names.Count;
+        var refreshed = 0;
 
         foreach (var name in names)
         {
             try
             {
-                var item = _libraryManager.GetStudio(name);
+                Studio? item = null;
+                if (existingStudios.TryGetValue(name, out var existingStudio))
+                {
+                    item = existingStudio;
+                }
 
-                await item.RefreshMetadata(cancellationToken).ConfigureAwait(false);
+                // Fall back to GetStudio if not found (creates new item if needed)
+                item ??= _libraryManager.GetStudio(name);
+
+                if (!existingStudioIds.Contains(item.Id))
+                {
+                    await item.RefreshMetadata(cancellationToken).ConfigureAwait(false);
+                    refreshed++;
+                }
             }
             catch (OperationCanceledException)
             {
@@ -79,6 +103,8 @@ public class StudiosValidator
             progress.Report(percent);
         }
 
+        _logger.LogInformation("Refreshed metadata for {RefreshedCount} new studios out of {TotalCount} total", refreshed, count);
+
         var deadEntities = _libraryManager.GetItemList(new InternalItemsQuery
         {
             IncludeItemTypes = [BaseItemKind.Studio],
@@ -89,16 +115,10 @@ public class StudiosValidator
         foreach (var item in deadEntities)
         {
             _logger.LogInformation("Deleting dead {ItemType} {ItemId} {ItemName}", item.GetType().Name, item.Id.ToString("N", CultureInfo.InvariantCulture), item.Name);
-
-            _libraryManager.DeleteItem(
-                item,
-                new DeleteOptions
-                {
-                    DeleteFileLocation = false
-                },
-                false);
         }
 
+        _libraryManager.DeleteItemsUnsafeFast(deadEntities, deleteSourceFiles: true);
+
         progress.Report(100);
     }
 }

Emby.Server.Implementations/Localization/Core/ab.json

@@ -1,3 +1,3 @@
 {
-    "Albums": "аальбомқәа"
+    "AppDeviceValues": "Апп: {0}, Априбор: {1}"
 }

Emby.Server.Implementations/Localization/Core/af.json

@@ -1,11 +1,8 @@
 {
     "Artists": "Kunstenare",
-    "Channels": "Kanale",
     "Folders": "Lêergidse",
     "Favorites": "Gunstelinge",
     "HeaderFavoriteShows": "Gunsteling Vertonings",
-    "ValueSpecialEpisodeName": "Spesiale - {0}",
-    "HeaderAlbumArtists": "Album kunstenaars",
     "Books": "Boeke",
     "HeaderNextUp": "Volgende",
     "Movies": "Flieks",
@@ -13,24 +10,13 @@
     "HeaderContinueWatching": "Hou aan kyk",
     "HeaderFavoriteEpisodes": "Gunsteling Episodes",
     "Photos": "Foto's",
-    "Playlists": "Snitlyste",
-    "HeaderFavoriteArtists": "Gunsteling Kunstenaars",
-    "HeaderFavoriteAlbums": "Gunsteling Albums",
-    "Sync": "Sinkroniseer",
-    "HeaderFavoriteSongs": "Gunsteling Liedjies",
-    "Songs": "Liedjies",
-    "DeviceOnlineWithName": "{0} is aanlyn",
-    "DeviceOfflineWithName": "{0} is ontkoppel",
     "Collections": "Versamelings",
     "Inherit": "Ontvang",
     "HeaderLiveTV": "Lewendige TV",
-    "Application": "Program",
     "AppDeviceValues": "App: {0}, Toestel: {1}",
     "VersionNumber": "Weergawe {0}",
-    "ValueHasBeenAddedToLibrary": "{0} is by jou media biblioteek bygevoeg",
     "UserStoppedPlayingItemWithValues": "{0} het klaar {1} op {2} gespeel",
     "UserStartedPlayingItemWithValues": "{0} is besig om {1} op {2} te speel",
-    "UserPolicyUpdatedWithName": "Gebruiker beleid is verander vir {0}",
     "UserPasswordChangedWithName": "Gebruiker {0} se wagwoord is verander",
     "UserOnlineFromDevice": "{0} is aanlyn van {1}",
     "UserOfflineFromDevice": "{0} is ontkoppel van {1}",
@@ -38,19 +24,13 @@
     "UserDownloadingItemWithValues": "{0} is besig om {1} af te laai",
     "UserDeletedWithName": "Gebruiker {0} is verwyder",
     "UserCreatedWithName": "Gebruiker {0} is geskep",
-    "User": "Gebruiker",
     "TvShows": "TV Programme",
-    "System": "Stelsel",
     "SubtitleDownloadFailureFromForItem": "Ondertitels het misluk om af te laai van {0} vir {1}",
     "StartupEmbyServerIsLoading": "Jellyfin Bediener is besig om te laai. Probeer weer in 'n kort tyd.",
-    "ServerNameNeedsToBeRestarted": "{0} moet herbegin word",
-    "ScheduledTaskStartedWithName": "{0} het begin",
     "ScheduledTaskFailedWithName": "{0} het misluk",
-    "ProviderValue": "Voorsiener: {0}",
     "PluginUpdatedWithName": "{0} was opgedateer",
     "PluginUninstalledWithName": "{0} was verwyder",
     "PluginInstalledWithName": "{0} is geïnstalleer",
-    "Plugin": "Inprop module",
     "NotificationOptionVideoPlaybackStopped": "Video terugspeel het gestop",
     "NotificationOptionVideoPlayback": "Video terugspeel het begin",
     "NotificationOptionUserLockedOut": "Gebruiker uitgeslyt",
@@ -74,23 +54,14 @@
     "MusicVideos": "Musiek Videos",
     "Music": "Musiek",
     "MixedContent": "Gemengde inhoud",
-    "MessageServerConfigurationUpdated": "Bediener konfigurasie is opgedateer",
-    "MessageNamedServerConfigurationUpdatedWithValue": "Bediener konfigurasie seksie {0} is opgedateer",
-    "MessageApplicationUpdatedTo": "Jellyfin Bediener is opgedateer na {0}",
-    "MessageApplicationUpdated": "Jellyfin Bediener is opgedateer",
     "Latest": "Nuutste",
     "LabelRunningTimeValue": "Werktyd: {0}",
     "LabelIpAddressValue": "IP adres: {0}",
-    "ItemRemovedWithName": "{0} is uit versameling verwyder",
-    "ItemAddedWithName": "{0} is by die versameling gevoeg",
     "HomeVideos": "Tuis Videos",
-    "HeaderRecordingGroups": "Groep Opnames",
     "Genres": "Genres",
     "FailedLoginAttemptWithUserName": "Mislukte aanmeldpoging van {0}",
     "ChapterNameValue": "Hoofstuk {0}",
-    "CameraImageUploadedFrom": "'n Nuwe kamera foto is opgelaai vanaf {0}",
     "AuthenticationSucceededWithUserName": "{0} suksesvol geverifieer",
-    "Albums": "Albums",
     "TasksChannelsCategory": "Internet kanale",
     "TasksApplicationCategory": "aansoek",
     "TasksLibraryCategory": "biblioteek",
@@ -128,12 +99,12 @@
     "TaskRefreshTrickplayImagesDescription": "Skep fopspeel voorskou vir videos in aangeskakelde media versameling.",
     "TaskAudioNormalizationDescription": "Skandeer lêers vir oudio-normaliseringsdata.",
     "TaskAudioNormalization": "Odio Normalisering",
-    "TaskCleanCollectionsAndPlaylists": "Maak versamelings en snitlyste skoon",
-    "TaskCleanCollectionsAndPlaylistsDescription": "Verwyder items uit versamelings en snitlyste wat nie meer bestaan nie.",
     "TaskDownloadMissingLyrics": "Laai tekorte lirieke af",
     "TaskDownloadMissingLyricsDescription": "Laai lirieke af vir liedjies",
     "TaskExtractMediaSegments": "Media Segment Skandeer",
     "TaskExtractMediaSegmentsDescription": "Onttrek of verkry mediasegmente van MediaSegment-geaktiveerde inproppe.",
     "TaskMoveTrickplayImages": "Migreer Trickplay Beeldligging",
-    "TaskMoveTrickplayImagesDescription": "Skuif ontstaande trickplay lêers volgens die biblioteekinstellings."
+    "TaskMoveTrickplayImagesDescription": "Skuif ontstaande trickplay lêers volgens die biblioteekinstellings.",
+    "CleanupUserDataTask": "Gebruikers data skoon maak taak",
+    "CleanupUserDataTaskDescription": "Maak alle gebruikers data (kykstatus, gunstelingstatus, ens.) skoon van media wat nie meer vir ten minste 90 dae teenwoordig is nie."
 }

Emby.Server.Implementations/Localization/Core/ar.json

@@ -1,142 +1,112 @@
 {
-    "Albums": "ألبومات",
+    "AppDeviceValues": "التطبيق: {0}، الجهاز: {1}",
-    "AppDeviceValues": "تطبيق: {0}, جهاز: {1}",
-    "Application": "تطبيق",
     "Artists": "الفنانون",
-    "AuthenticationSucceededWithUserName": "نجحت عملية التوثيق بـ {0}",
+    "AuthenticationSucceededWithUserName": "تمت مصادقة {0} بنجاح",
     "Books": "الكتب",
-    "CameraImageUploadedFrom": "رُفعت صورة الكاميرا الجديدة من {0}",
-    "Channels": "القنوات",
     "ChapterNameValue": "الفصل {0}",
     "Collections": "المجموعات",
-    "DeviceOfflineWithName": "قُطِع الاتصال ب{0}",
+    "FailedLoginAttemptWithUserName": "محاولة تسجيل دخول فاشلة من {0}",
-    "DeviceOnlineWithName": "{0} متصل",
-    "FailedLoginAttemptWithUserName": "محاولة تسجيل الدخول فاشلة من {0}",
     "Favorites": "المفضلة",
     "Folders": "المجلدات",
-    "Genres": "التصنيفات",
+    "Genres": "الأنواع",
-    "HeaderAlbumArtists": "فناني الألبوم",
+    "HeaderContinueWatching": "متابعة المشاهدة",
-    "HeaderContinueWatching": "إستئناف المشاهدة",
-    "HeaderFavoriteAlbums": "الألبومات المفضلة",
-    "HeaderFavoriteArtists": "الفنانون المفضلون",
     "HeaderFavoriteEpisodes": "الحلقات المفضلة",
     "HeaderFavoriteShows": "المسلسلات المفضلة",
-    "HeaderFavoriteSongs": "الأغاني المفضلة",
+    "HeaderLiveTV": "البث التلفزيوني المباشر",
-    "HeaderLiveTV": "التلفاز المباشر",
     "HeaderNextUp": "التالي",
-    "HeaderRecordingGroups": "مجموعات التسجيل",
+    "HomeVideos": "فيديوهات منزلية",
-    "HomeVideos": "الفيديوهات الشخصية",
+    "Inherit": "وراثة",
-    "Inherit": "توريث",
+    "LabelIpAddressValue": "عنوان IP: {0}",
-    "ItemAddedWithName": "أُضيف {0} للمكتبة",
-    "ItemRemovedWithName": "أُزيل {0} من المكتبة",
-    "LabelIpAddressValue": "عنوان الآي بي: {0}",
     "LabelRunningTimeValue": "مدة التشغيل: {0}",
     "Latest": "الأحدث",
-    "MessageApplicationUpdated": "حُدث خادم Jellyfin",
-    "MessageApplicationUpdatedTo": "حُدث خادم Jellyfin إلى {0}",
-    "MessageNamedServerConfigurationUpdatedWithValue": "حُدثت إعدادات الخادم في قسم {0}",
-    "MessageServerConfigurationUpdated": "حُدثت إعدادات الخادم",
     "MixedContent": "محتوى مختلط",
     "Movies": "الأفلام",
     "Music": "الموسيقى",
     "MusicVideos": "الفيديوهات الموسيقية",
     "NameInstallFailed": "فشل تثبيت {0}",
     "NameSeasonNumber": "الموسم {0}",
-    "NameSeasonUnknown": "الموسم غير معروف",
+    "NameSeasonUnknown": "موسم غير معروف",
-    "NewVersionIsAvailable": "نسخة جديدة من خادم Jellyfin متوفرة للتحميل.",
+    "NewVersionIsAvailable": "يتوفر إصدار جديد من خادم Jellyfin للتنزيل.",
-    "NotificationOptionApplicationUpdateAvailable": "يوجد تحديث للتطبيق",
+    "NotificationOptionApplicationUpdateAvailable": "تحديث التطبيق متاح",
-    "NotificationOptionApplicationUpdateInstalled": "نُصب تحديث التطبيق",
+    "NotificationOptionApplicationUpdateInstalled": "تم تثبيت تحديث التطبيق",
-    "NotificationOptionAudioPlayback": "بدأ تشغيل المقطع الصوتي",
+    "NotificationOptionAudioPlayback": "بدأ تشغيل الصوت",
-    "NotificationOptionAudioPlaybackStopped": "أُوقف تشغيل المقطع الصوتي",
+    "NotificationOptionAudioPlaybackStopped": "توقف تشغيل الصوت",
-    "NotificationOptionCameraImageUploaded": "رُفعت صورة الكاميرا",
+    "NotificationOptionCameraImageUploaded": "تم رفع صورة كاميرا",
-    "NotificationOptionInstallationFailed": "فشل في التثبيت",
+    "NotificationOptionInstallationFailed": "فشل التثبيت",
-    "NotificationOptionNewLibraryContent": "أُضيف محتوى جديدا",
+    "NotificationOptionNewLibraryContent": "تمت إضافة محتوى جديد",
-    "NotificationOptionPluginError": "فشل في الملحق",
+    "NotificationOptionPluginError": "خطأ في الملحق",
-    "NotificationOptionPluginInstalled": "ثُبتت الملحق",
+    "NotificationOptionPluginInstalled": "تم تثبيت الملحق",
     "NotificationOptionPluginUninstalled": "تمت إزالة الملحق",
-    "NotificationOptionPluginUpdateInstalled": "تم تثبيت تحديثات الملحق",
+    "NotificationOptionPluginUpdateInstalled": "تم تحديث الملحق",
-    "NotificationOptionServerRestartRequired": "يجب إعادة تشغيل الخادم",
+    "NotificationOptionServerRestartRequired": "مطلوب إعادة تشغيل الخادم",
-    "NotificationOptionTaskFailed": "فشل في المهمة المجدولة",
+    "NotificationOptionTaskFailed": "فشل المهمة المجدولة",
-    "NotificationOptionUserLockedOut": "تم إقفال حساب المستخدم",
+    "NotificationOptionUserLockedOut": "تم قفل حساب المستخدم",
     "NotificationOptionVideoPlayback": "بدأ تشغيل الفيديو",
-    "NotificationOptionVideoPlaybackStopped": "تم إيقاف تشغيل الفيديو",
+    "NotificationOptionVideoPlaybackStopped": "توقف تشغيل الفيديو",
     "Photos": "الصور",
-    "Playlists": "قوائم التشغيل",
-    "Plugin": "الملحق",
     "PluginInstalledWithName": "تم تثبيت {0}",
     "PluginUninstalledWithName": "تمت إزالة {0}",
     "PluginUpdatedWithName": "تم تحديث {0}",
-    "ProviderValue": "المزود: {0}",
+    "ScheduledTaskFailedWithName": "فشلت {0}",
-    "ScheduledTaskFailedWithName": "فشلت العملية {0}",
+    "Shows": "المسلسلات",
-    "ScheduledTaskStartedWithName": "تم بدء العملية {0}",
+    "StartupEmbyServerIsLoading": "يتم الآن تحميل خادم Jellyfin. يرجى المحاولة مرة أخرى بعد قليل.",
-    "ServerNameNeedsToBeRestarted": "يحتاج {0} لإعادة التشغيل",
+    "SubtitleDownloadFailureFromForItem": "فشل تنزيل الترجمات من {0} لـ {1}",
-    "Shows": "العروض",
-    "Songs": "الأغاني",
-    "StartupEmbyServerIsLoading": "يتم تحميل خادم Jellyfin . الرجاء المحاولة بعد قليل.",
-    "SubtitleDownloadFailureForItem": "عملية إنزال الترجمة فشلت لـ{0}",
-    "SubtitleDownloadFailureFromForItem": "فشل تحميل الترجمات من {0} ل {1}",
-    "Sync": "مزامنة",
-    "System": "النظام",
     "TvShows": "البرامج التلفزيونية",
-    "User": "المستخدم",
     "UserCreatedWithName": "تم إنشاء المستخدم {0}",
     "UserDeletedWithName": "تم حذف المستخدم {0}",
-    "UserDownloadingItemWithValues": "يقوم {0} بتنزيل {1}",
+    "UserDownloadingItemWithValues": "{0} يقوم بتنزيل {1}",
-    "UserLockedOutWithName": "تم منع المستخدم {0} من الدخول",
+    "UserLockedOutWithName": "تم قفل حساب المستخدم {0}",
-    "UserOfflineFromDevice": "تم قطع اتصال {0} من {1}",
+    "UserOfflineFromDevice": "انقطع اتصال {0} من {1}",
-    "UserOnlineFromDevice": "{0} متصل عبر {1}",
+    "UserOnlineFromDevice": "{0} متصل من {1}",
-    "UserPasswordChangedWithName": "تم تغيير كلمة السر للمستخدم {0}",
+    "UserPasswordChangedWithName": "تم تغيير كلمة المرور للمستخدم {0}",
-    "UserPolicyUpdatedWithName": "تم تحديث سياسة المستخدم {0}",
+    "UserStartedPlayingItemWithValues": "{0} يقوم بتشغيل {1} على {2}",
-    "UserStartedPlayingItemWithValues": "قام {0} ببدء تشغيل {1} على {2}",
+    "UserStoppedPlayingItemWithValues": "أنهى {0} تشغيل {1} على {2}",
-    "UserStoppedPlayingItemWithValues": "قام {0} بإيقاف تشغيل {1} على {2}",
-    "ValueHasBeenAddedToLibrary": "تمت اضافت {0} إلى مكتبة الوسائط",
-    "ValueSpecialEpisodeName": "حلقة خاصه - {0}",
     "VersionNumber": "الإصدار {0}",
-    "TaskCleanCacheDescription": "يحذف الملفات المؤقتة التي لم يعد النظام بحاجة إليها.",
+    "TaskCleanCacheDescription": "يحذف ملفات ذاكرة التخزين المؤقت التي لم يعد النظام بحاجة إليها.",
-    "TaskCleanCache": "حذف الملفات المؤقتة",
+    "TaskCleanCache": "تنظيف مجلد ذاكرة التخزين المؤقت",
     "TasksChannelsCategory": "قنوات الإنترنت",
-    "TasksLibraryCategory": "مكتبة",
+    "TasksLibraryCategory": "المكتبة",
-    "TasksMaintenanceCategory": "صيانة",
+    "TasksMaintenanceCategory": "الصيانة",
-    "TaskRefreshLibraryDescription": "يفحص مكتبة الوسائط الخاصة بك باحثا عن ملفات جديدة، ومن ثم يُحدث البيانات الوصفية.",
+    "TaskRefreshLibraryDescription": "يفحص مكتبة المحتوى الخاصة بك بحثاً عن ملفات جديدة ويحدّث البيانات الوصفية.",
-    "TaskRefreshLibrary": "افحص مكتبة الوسائط",
+    "TaskRefreshLibrary": "فحص مكتبة المحتوى",
-    "TaskRefreshChapterImagesDescription": "يُنشئ صور مصغرة لمقاطع الفيديو التي تحتوي على فصول.",
+    "TaskRefreshChapterImagesDescription": "ينشئ صوراً مصغرة للفيديوهات التي تحتوي على فصول.",
-    "TaskRefreshChapterImages": "استخراج صور الفصل",
+    "TaskRefreshChapterImages": "استخراج صور الفصول",
-    "TasksApplicationCategory": "تطبيق",
+    "TasksApplicationCategory": "التطبيق",
-    "TaskDownloadMissingSubtitlesDescription": "يبحث في الإنترنت على الترجمات الناقصة استنادا على البيانات الوصفية.",
+    "TaskDownloadMissingSubtitlesDescription": "يبحث في الإنترنت عن الترجمات المفقودة بناءً على إعدادات البيانات الوصفية.",
-    "TaskDownloadMissingSubtitles": "تحميل الترجمات الناقصة",
+    "TaskDownloadMissingSubtitles": "تنزيل الترجمات المفقودة",
-    "TaskRefreshChannelsDescription": "يحدث معلومات قنوات الإنترنت.",
+    "TaskRefreshChannelsDescription": "يحدّث معلومات قنوات الإنترنت.",
-    "TaskRefreshChannels": "إعادة تحديث القنوات",
+    "TaskRefreshChannels": "تحديث القنوات",
-    "TaskCleanTranscodeDescription": "يحذف ملفات الترميز الأقدم من يوم واحد.",
+    "TaskCleanTranscodeDescription": "يحذف ملفات تحويل الترميز التي مر عليها أكثر من يوم واحد.",
-    "TaskCleanTranscode": "حذف ما بمجلد الترميز",
+    "TaskCleanTranscode": "تنظيف مجلد تحويل الترميز",
-    "TaskUpdatePluginsDescription": "تحميل وتثبيت الإضافات التي تم تفعيل التحديث التلقائي لها.",
+    "TaskUpdatePluginsDescription": "ينزّل ويثبّت التحديثات للملحقات المهيأة للتحديث التلقائي.",
-    "TaskUpdatePlugins": "تحديث الإضافات",
+    "TaskUpdatePlugins": "تحديث الملحقات",
-    "TaskRefreshPeopleDescription": "يقوم بتحديث البيانات الوصفية للممثلين والمخرجين في مكتبة الوسائط الخاصة بك.",
+    "TaskRefreshPeopleDescription": "يحدّث البيانات الوصفية للممثلين والمخرجين في مكتبة المحتوى الخاصة بك.",
-    "TaskRefreshPeople": "إعادة تحميل الأشخاص",
+    "TaskRefreshPeople": "تحديث الأشخاص",
-    "TaskCleanLogsDescription": "يحذف السجلات الأقدم من {0} يوم.",
+    "TaskCleanLogsDescription": "يحذف ملفات السجل التي يزيد عمرها عن {0} أيام.",
-    "TaskCleanLogs": "حذف مسار السجل",
+    "TaskCleanLogs": "تنظيف مجلد السجلات",
-    "TaskCleanActivityLogDescription": "يحذف سجل الأنشطة الأقدم من الوقت الذي تم تحديده.",
+    "TaskCleanActivityLogDescription": "يحذف إدخالات سجل النشاط الأقدم من العمر المحدد.",
-    "TaskCleanActivityLog": "حذف سجل الأنشطة",
+    "TaskCleanActivityLog": "تنظيف سجل النشاط",
-    "Default": "افتراضي",
+    "Default": "الافتراضي",
-    "Undefined": "غير معرف",
+    "Undefined": "غير محدد",
-    "Forced": "ملحقة",
+    "Forced": "إجباري",
-    "TaskOptimizeDatabaseDescription": "يضغط قاعدة البيانات ويقتطع المساحة الحرة. تشغيل هذه المهمة بعد فحص المكتبة أو إجراء تغييرات أخرى تتضمن تعديلات في قاعدة البيانات قد تؤدي إلى تحسين الأداء.",
+    "TaskOptimizeDatabaseDescription": "يضغط قاعدة البيانات ويقلل المساحة الحرة. قد يؤدي تشغيل هذه المهمة بعد فحص المكتبة أو إجراء تغييرات أخرى تتضمن تعديلات على قاعدة البيانات إلى تحسين الأداء.",
     "TaskOptimizeDatabase": "تحسين قاعدة البيانات",
-    "TaskKeyframeExtractorDescription": "يستخرج الإطارات الرئيسية من ملفات الفيديو لكي ينشئ قوائم تشغيل بث HTTP المباشر. قد تستمر هذه العملية لوقت طويل.",
+    "TaskKeyframeExtractorDescription": "يستخرج الإطارات الرئيسية من ملفات الفيديو لإنشاء قوائم تشغيل HLS أكثر دقة. قد يستغرق تشغيل هذه المهمة وقتاً طويلاً.",
-    "TaskKeyframeExtractor": "مستخرج الإطار الرئيسي",
+    "TaskKeyframeExtractor": "مستخرج الإطارات الرئيسية",
     "External": "خارجي",
-    "HearingImpaired": "ضعاف السمع",
+    "HearingImpaired": "لضعاف السمع",
-    "TaskRefreshTrickplayImages": "توليد صور المعاينة السريعة",
+    "TaskRefreshTrickplayImages": "إنشاء صور معاينات التنقل (Trickplay)",
-    "TaskRefreshTrickplayImagesDescription": "يُولّد معاينات تنقل سريع لمقاطع الفيديو ضمن المكتبات المفعّلة.",
+    "TaskRefreshTrickplayImagesDescription": "ينشئ صور معاينات التنقل السريع للفيديوهات في المكتبات المفعّلة.",
-    "TaskCleanCollectionsAndPlaylists": "حذف المجموعات وقوائم التشغيل",
+    "TaskAudioNormalization": "تطبيع الصوت",
-    "TaskCleanCollectionsAndPlaylistsDescription": "حذف عناصر من المجموعات وقوائم التشغيل التي لم تعد موجودة.",
+    "TaskAudioNormalizationDescription": "يفحص الملفات لجمع بيانات تطبيع الصوت.",
-    "TaskAudioNormalization": "تسوية الصوت",
+    "TaskDownloadMissingLyrics": "تنزيل الكلمات المفقودة",
-    "TaskAudioNormalizationDescription": "مسح الملفات لتطبيع بيانات الصوت.",
+    "TaskDownloadMissingLyricsDescription": "ينزّل الكلمات للأغاني.",
-    "TaskDownloadMissingLyrics": "تنزيل عبارات القصيدة",
+    "TaskExtractMediaSegments": "فحص مقاطع المحتوى",
-    "TaskDownloadMissingLyricsDescription": "كلمات",
+    "TaskExtractMediaSegmentsDescription": "يستخرج أو يحصل على مقاطع المحتوى من الملحقات المفعّلة لمقاطع المحتوى (MediaSegment).",
-    "TaskExtractMediaSegments": "فحص مقاطع الوسائط",
+    "TaskMoveTrickplayImages": "نقل موقع صور معاينات التنقل",
-    "TaskExtractMediaSegmentsDescription": "يستخرج مقاطع وسائط من إضافات MediaSegment المُفعّلة.",
+    "TaskMoveTrickplayImagesDescription": "ينقل ملفات معاينات التنقل الحالية وفقاً لإعدادات المكتبة.",
-    "TaskMoveTrickplayImages": "تغيير مكان صور المعاينة السريعة",
-    "TaskMoveTrickplayImagesDescription": "تُنقل ملفات التشغيل السريع الحالية بناءً على إعدادات المكتبة.",
     "CleanupUserDataTask": "مهمة تنظيف بيانات المستخدم",
-    "CleanupUserDataTaskDescription": "مسح جميع بيانات المستخدم (حالة المشاهدة، والحالة المفضلة وما إلى ذلك) من الوسائط التي لم تعد موجودة لمدة 90 يومًا على الأقل."
+    "CleanupUserDataTaskDescription": "ينظف جميع بيانات المستخدم (مثل حالة المشاهدة وحالة المفضلة وغيرها) للمحتوى الذي لم يعد موجوداً لمدة 90 يوماً على الأقل.",
+    "Original": "فريد",
+    "LyricDownloadFailureFromForItem": "فشل تحميل الكلمات من {0} إلى {1}"
 }

Emby.Server.Implementations/Localization/Core/ar_SA.json

@@ -0,0 +1 @@
+{}

Emby.Server.Implementations/Localization/Core/as.json

@@ -1,18 +1,13 @@
 {
-    "Albums": "এলবাম",
-    "Application": "আবেদন",
     "AppDeviceValues": "এপ্‌: {0}, ডিভাইচ: {1}",
     "Artists": "শিল্পী",
-    "Channels": "চেনেলস",
     "Default": "ডিফল্ট",
     "AuthenticationSucceededWithUserName": "{0} সফলভাবে প্রমাণিত",
     "Books": "পুস্তক",
     "Movies": "চলচ্চিত্ৰ",
-    "CameraImageUploadedFrom": "একটি নতুন ক্যামেরা চিত্র আপলোড করা হয়েছে {0}",
     "Collections": "সংগ্রহ",
     "HeaderFavoriteShows": "প্রিয় শোসমূহ",
     "Latest": "শেহতীয়া",
-    "MessageApplicationUpdated": "জেলিফিন চাইভাৰ আপডেট কৰা হৈছে",
     "MixedContent": "মিশ্ৰিত সমগ্ৰতা",
     "NewVersionIsAvailable": "ডাউনলোড কৰিবলৈ জেলিফিন চাইভাৰৰ এটা নতুন সংস্কৰণ উপলব্ধ আছে.",
     "NotificationOptionCameraImageUploaded": "কেমেৰাৰ চিত্ৰ আপল'ড কৰা হ'ল",
@@ -21,20 +16,14 @@
     "Folders": "ফোল্ডাৰ",
     "Forced": "বলপূর্বক",
     "Genres": "শ্রেণী",
-    "HeaderAlbumArtists": "অ্যালবাম শিল্পী",
     "HeaderContinueWatching": "দেখা চালিয়ে যান",
     "FailedLoginAttemptWithUserName": "লগইন ব্যর্থ চেষ্টা কৰা হৈছে থেকে {0}",
-    "HeaderFavoriteAlbums": "প্রিয় অ্যালবামসমূহ",
-    "HeaderFavoriteArtists": "প্রিয় শিল্পীসমূহ",
     "HeaderFavoriteEpisodes": "প্রিয় পর্বসমূহ",
-    "HeaderFavoriteSongs": "প্ৰিয় গীত",
     "HeaderLiveTV": "প্ৰতিবেদন টিভি",
     "HeaderNextUp": "পৰৱৰ্তী অংশ",
-    "HeaderRecordingGroups": "অলংকৰণ গোষ্ঠীসমূহ",
     "HearingImpaired": "শ্ৰবণ অক্ষম",
     "HomeVideos": "ঘৰৰ ভিডিঅ'সমূহ",
     "Inherit": "উত্তপ্ত কৰা",
-    "MessageServerConfigurationUpdated": "চাইভাৰ কনফিগাৰেশ্যন আপডেট কৰা হৈছে",
     "NotificationOptionApplicationUpdateAvailable": "অ্যাপ্লিকেশ্যন আপডেট উপলব্ধ",
     "NotificationOptionApplicationUpdateInstalled": "অ্যাপ্লিকেশ্যন আপডেট ইনষ্টল কৰা হ'ল",
     "NotificationOptionAudioPlayback": "অডিঅ' প্লেবেক আৰম্ভ হ'ল",

Emby.Server.Implementations/Localization/Core/be.json

@@ -1,36 +1,24 @@
 {
-    "Sync": "Сінхранізаваць",
-    "Playlists": "Плэй-лісты",
     "Latest": "Апошняе",
     "LabelIpAddressValue": "IP-адрас: {0}",
-    "ItemAddedWithName": "{0} даданы ў бібліятэку",
-    "MessageApplicationUpdated": "Сервер Jellyfin абноўлены",
     "NotificationOptionApplicationUpdateInstalled": "Абнаўленне праграмы ўсталявана",
     "PluginInstalledWithName": "{0} быў усталяваны",
     "UserCreatedWithName": "Карыстальнік {0} быў створаны",
-    "Albums": "Альбомы",
-    "Application": "Праграма",
     "AuthenticationSucceededWithUserName": "{0} паспяхова аўтарызаваны",
-    "Channels": "Каналы",
     "ChapterNameValue": "Раздзел {0}",
     "Collections": "Калекцыі",
-    "Default": "Па змаўчанні",
+    "Default": "Прадвызначана",
     "FailedLoginAttemptWithUserName": "Няўдалая спроба ўваходу з {0}",
-    "Folders": "Тэчкі",
+    "Folders": "Папкі",
     "Favorites": "Абранае",
     "External": "Знешні",
     "Genres": "Жанры",
     "HeaderContinueWatching": "Працягнуць прагляд",
-    "HeaderFavoriteAlbums": "Абраныя альбомы",
     "HeaderFavoriteEpisodes": "Абраныя серыі",
     "HeaderFavoriteShows": "Абраныя шоу",
-    "HeaderFavoriteSongs": "Абраныя песні",
     "HeaderLiveTV": "Прамы эфір",
-    "HeaderAlbumArtists": "Выканаўцы альбома",
     "LabelRunningTimeValue": "Працягласць: {0}",
     "HomeVideos": "Хатнія відэа",
-    "ItemRemovedWithName": "{0} выдалены з бібліятэкі",
-    "MessageApplicationUpdatedTo": "Сервер Jellyfin абноўлены да версіі {0}",
     "Movies": "Фільмы",
     "Music": "Музыка",
     "MusicVideos": "Музычныя кліпы",
@@ -41,48 +29,35 @@
     "NotificationOptionPluginUpdateInstalled": "Абнаўленне плагіна ўсталявана",
     "NotificationOptionServerRestartRequired": "Патрабуецца перазапуск сервера",
     "Photos": "Фотаздымкі",
-    "Plugin": "Плагін",
     "PluginUninstalledWithName": "{0} быў выдалены",
     "PluginUpdatedWithName": "{0} быў абноўлены",
-    "ProviderValue": "Пастаўшчык: {0}",
-    "Songs": "Песні",
-    "System": "Сістэма",
-    "User": "Карыстальнік",
     "UserDeletedWithName": "Карыстальнік {0} быў выдалены",
     "UserDownloadingItemWithValues": "{0} спампоўваецца {1}",
-    "TaskOptimizeDatabase": "Аптымізаваць базу дадзеных",
+    "TaskOptimizeDatabase": "Аптымізацыя базы даных",
     "Artists": "Выканаўцы",
     "UserOfflineFromDevice": "{0} адлучыўся ад {1}",
-    "UserPolicyUpdatedWithName": "Палітыка карыстальніка абноўлена для {0}",
     "TaskCleanActivityLogDescription": "Выдаляе запісы старэйшыя за зададзены ўзрост ў журнале актыўнасці.",
     "TaskRefreshChapterImagesDescription": "Стварае мініяцюры для відэа, якія маюць раздзелы.",
     "TaskCleanLogsDescription": "Выдаляе файлы журналу, якім больш за {0} дзён.",
     "TaskUpdatePluginsDescription": "Спампоўвае і ўсталёўвае абнаўленні для плагінаў, якія сканфігураваныя на аўтаматычнае абнаўленне.",
     "TaskRefreshChannelsDescription": "Абнаўляе інфармацыю аб інтэрнэт-канале.",
-    "TaskDownloadMissingSubtitlesDescription": "Шукае ў інтэрнэце адсутныя субцітры на аснове канфігурацыі метададзеных.",
+    "TaskDownloadMissingSubtitlesDescription": "Шукае ў інтэрнэце адсутныя субцітры на аснове канфігурацыі метаданых.",
-    "TaskOptimizeDatabaseDescription": "Ушчыльняе базу дадзеных і скарачае вольную прастору. Выкананне гэтай задачы пасля сканавання бібліятэкі або ўнясення іншых зменаў, якія прадугледжваюць мадыфікацыю базы дадзеных, можа палепшыць выдайнасць.",
+    "TaskOptimizeDatabaseDescription": "Сціскае базу даных і вызваляе вольную прастору. Выкананне гэтай задачы пасля сканіравання бібліятэкі або іншых змяненняў, якія мадыфікуюць базу даных, можа палепшыць прадукцыйнасць.",
     "TaskKeyframeExtractor": "Экстрактар ключавых кадраў",
     "TasksApplicationCategory": "Праграма",
     "AppDeviceValues": "Праграма: {0}, Прылада: {1}",
     "Books": "Кнігі",
-    "CameraImageUploadedFrom": "Новая выява камеры была загружана з {0}",
-    "DeviceOfflineWithName": "{0} адлучыўся",
-    "DeviceOnlineWithName": "{0} падлучаны",
     "Forced": "Прымусова",
-    "HeaderRecordingGroups": "Групы запісаў",
     "HeaderNextUp": "Наступнае",
-    "HeaderFavoriteArtists": "Абраныя выканаўцы",
     "HearingImpaired": "Са слабым слыхам",
     "Inherit": "Атрымаць у спадчыну",
-    "MessageNamedServerConfigurationUpdatedWithValue": "Канфігурацыя сервера (секцыя {0}) абноўлена",
-    "MessageServerConfigurationUpdated": "Канфігурацыя сервера абноўлена",
     "MixedContent": "Змешаны змест",
     "NameSeasonUnknown": "Невядомы сезон",
     "NotificationOptionInstallationFailed": "Збой усталёўкі",
     "NewVersionIsAvailable": "Новая версія сервера Jellyfin даступная для cпампоўкі.",
     "NotificationOptionCameraImageUploaded": "Выява камеры запампавана",
-    "NotificationOptionAudioPlaybackStopped": "Прайграванне аўдыё спынена",
+    "NotificationOptionAudioPlaybackStopped": "Прайграванне аўдыя спынена",
-    "NotificationOptionAudioPlayback": "Прайграванне аўдыё пачалося",
+    "NotificationOptionAudioPlayback": "Прайграванне аўдыя пачалося",
     "NotificationOptionNewLibraryContent": "Дададзены новы кантэнт",
     "NotificationOptionPluginError": "Збой плагіна",
     "NotificationOptionPluginUninstalled": "Плагін выдалены",
@@ -91,11 +66,9 @@
     "NotificationOptionVideoPlayback": "Пачалося прайграванне відэа",
     "NotificationOptionVideoPlaybackStopped": "Прайграванне відэа спынена",
     "ScheduledTaskFailedWithName": "{0} не атрымалася",
-    "ScheduledTaskStartedWithName": "{0} пачалося",
-    "ServerNameNeedsToBeRestarted": "{0} патрабуе перазапуску",
     "Shows": "Шоу",
     "StartupEmbyServerIsLoading": "Jellyfin Server загружаецца. Калі ласка, паўтарыце спробу крыху пазней.",
-    "SubtitleDownloadFailureFromForItem": "Не атрымалася спампаваць субтытры з {0} для {1}",
+    "SubtitleDownloadFailureFromForItem": "Субцітры для {1} не ўдалося спампаваць з {0}",
     "TvShows": "Тэлепраграма",
     "Undefined": "Нявызначана",
     "UserLockedOutWithName": "Карыстальнік {0} быў заблакіраваны",
@@ -103,8 +76,6 @@
     "UserPasswordChangedWithName": "Пароль быў зменены для карыстальніка {0}",
     "UserStartedPlayingItemWithValues": "{0} прайграваецца {1} на {2}",
     "UserStoppedPlayingItemWithValues": "{0} скончыў прайграванне {1} на {2}",
-    "ValueHasBeenAddedToLibrary": "{0} быў дададзены ў вашу медыятэку",
-    "ValueSpecialEpisodeName": "Спецэпізод - {0}",
     "VersionNumber": "Версія {0}",
     "TasksMaintenanceCategory": "Абслугоўванне",
     "TasksLibraryCategory": "Бібліятэка",
@@ -114,7 +85,7 @@
     "TaskCleanCacheDescription": "Выдаляе файлы кэша, якія больш не патрэбныя сістэме.",
     "TaskRefreshChapterImages": "Вынуць выявы раздзелаў",
     "TaskRefreshLibrary": "Сканаваць бібліятэку",
-    "TaskRefreshLibraryDescription": "Скануе вашу медыятэку на наяўнасць новых файлаў і абнаўляе метададзеныя.",
+    "TaskRefreshLibraryDescription": "Сканіруе вашу медыятэку на наяўнасць новых файлаў і абнаўляе метаданыя.",
     "TaskCleanLogs": "Ачысціць журнал",
     "TaskRefreshPeople": "Абнавіць выканаўцаў",
     "TaskRefreshPeopleDescription": "Абнаўленне метаданых для акцёраў і рэжысёраў у вашай медыятэцы.",
@@ -123,11 +94,9 @@
     "TaskCleanTranscodeDescription": "Выдаляе перакадзіраваныя файлы, старэйшыя за адзін дзень.",
     "TaskRefreshChannels": "Абнавіць каналы",
     "TaskDownloadMissingSubtitles": "Спампаваць адсутныя субцітры",
-    "TaskKeyframeExtractorDescription": "Выдае ключавыя кадры з відэафайлаў для стварэння больш дакладных плэй-лістоў HLS. Гэта задача можа працягнуцца шмат часу.",
+    "TaskKeyframeExtractorDescription": "Выдае ключавыя кадры з відэафайлаў для стварэння больш дакладных плэй-лістоў HLS. Гэта задача можа выконвацца доўга.",
     "TaskRefreshTrickplayImages": "Стварыць выявы Trickplay",
     "TaskRefreshTrickplayImagesDescription": "Стварае перадпрагляды відэаролікаў для Trickplay у падключаных бібліятэках.",
-    "TaskCleanCollectionsAndPlaylists": "Ачысціце калекцыі і плэй-лісты",
-    "TaskCleanCollectionsAndPlaylistsDescription": "Выдаляе элементы з калекцый і плэй-лістоў, якія больш не існуюць.",
     "TaskAudioNormalizationDescription": "Скануе файлы на прадмет нармалізацыі гуку.",
     "TaskAudioNormalization": "Нармалізацыя гуку",
     "TaskExtractMediaSegmentsDescription": "Выдае або атрымлівае медыясегменты з убудоў з падтрымкай MediaSegment.",
@@ -136,6 +105,6 @@
     "TaskDownloadMissingLyricsDescription": "Спампоўвае тэксты для песняў",
     "TaskExtractMediaSegments": "Сканіраванне медыя-сегмента",
     "TaskMoveTrickplayImages": "Перанесці месцазнаходжанне выявы Trickplay",
-    "CleanupUserDataTask": "Задача па ачыстцы дадзеных карыстальніка",
+    "CleanupUserDataTask": "Задача па ачыстцы даных карыстальніка",
-    "CleanupUserDataTaskDescription": "Ачысьціць усе дадзеныя карыстальніка (стан прагляду, абранае і г.д.) для медыяфайлаў, што адсутнічаюць больш за 90 дзён."
+    "CleanupUserDataTaskDescription": "Ачышчае ўсе даныя карыстальніка (стан прагляду, абранае і г.д.) для медыяфайлаў, што адсутнічаюць больш за 90 дзён."
 }

Emby.Server.Implementations/Localization/Core/bg-BG.json

@@ -1,41 +1,24 @@
 {
-    "Albums": "Албуми",
     "AppDeviceValues": "Програма: {0}, Устройство: {1}",
-    "Application": "Програма",
     "Artists": "Артисти",
     "AuthenticationSucceededWithUserName": "{0} се удостовери успешно",
     "Books": "Книги",
-    "CameraImageUploadedFrom": "Нова снимка от камера беше качена от {0}",
-    "Channels": "Канали",
     "ChapterNameValue": "Глава {0}",
     "Collections": "Колекции",
-    "DeviceOfflineWithName": "{0} се разкачи",
-    "DeviceOnlineWithName": "{0} е свързан",
     "FailedLoginAttemptWithUserName": "Неуспешен опит за влизане от {0}",
     "Favorites": "Любими",
     "Folders": "Папки",
     "Genres": "Жанрове",
-    "HeaderAlbumArtists": "Изпълнители на албуми",
     "HeaderContinueWatching": "Продължаване на гледането",
-    "HeaderFavoriteAlbums": "Любими албуми",
-    "HeaderFavoriteArtists": "Любими изпълнители",
     "HeaderFavoriteEpisodes": "Любими епизоди",
     "HeaderFavoriteShows": "Любими сериали",
-    "HeaderFavoriteSongs": "Любими песни",
     "HeaderLiveTV": "Телевизия на живо",
     "HeaderNextUp": "Следва",
-    "HeaderRecordingGroups": "Запис групи",
     "HomeVideos": "Домашни Клипове",
     "Inherit": "Наследяване",
-    "ItemAddedWithName": "{0} е добавено към библиотеката",
-    "ItemRemovedWithName": "{0} е премахнато от библиотеката",
     "LabelIpAddressValue": "IP адрес: {0}",
     "LabelRunningTimeValue": "Продължителност: {0}",
     "Latest": "Последни",
-    "MessageApplicationUpdated": "Сървърът беше обновен",
-    "MessageApplicationUpdatedTo": "Сървърът беше обновен до {0}",
-    "MessageNamedServerConfigurationUpdatedWithValue": "Секцията {0} от сървърната конфигурация беше актуализирана",
-    "MessageServerConfigurationUpdated": "Конфигурацията на сървъра беше актуализирана",
     "MixedContent": "Смесено съдържание",
     "Movies": "Филми",
     "Music": "Музика",
@@ -61,24 +44,14 @@
     "NotificationOptionVideoPlayback": "Възпроизвеждането на видео започна",
     "NotificationOptionVideoPlaybackStopped": "Възпроизвеждането на видео е спряно",
     "Photos": "Снимки",
-    "Playlists": "Списъци",
-    "Plugin": "Добавка",
     "PluginInstalledWithName": "{0} е инсталиранa",
     "PluginUninstalledWithName": "{0} е деинсталиранa",
     "PluginUpdatedWithName": "{0} е обновенa",
-    "ProviderValue": "Доставчик: {0}",
     "ScheduledTaskFailedWithName": "{0} се провали",
-    "ScheduledTaskStartedWithName": "{0} започна",
-    "ServerNameNeedsToBeRestarted": "{0} трябва да се рестартира",
     "Shows": "Сериали",
-    "Songs": "Песни",
     "StartupEmbyServerIsLoading": "Сървърът зарежда. Моля, опитайте отново след малко.",
-    "SubtitleDownloadFailureForItem": "Неуспешно изтегляне на субтитри за {0}",
     "SubtitleDownloadFailureFromForItem": "Субтитрите за {1} от {0} не можаха да бъдат изтеглени",
-    "Sync": "Синхронизиране",
-    "System": "Система",
     "TvShows": "Телевизионни сериали",
-    "User": "Потребител",
     "UserCreatedWithName": "Потребителят {0} е създаден",
     "UserDeletedWithName": "Потребителят {0} е изтрит",
     "UserDownloadingItemWithValues": "{0} изтегля {1}",
@@ -86,11 +59,8 @@
     "UserOfflineFromDevice": "{0} се разкачи от {1}",
     "UserOnlineFromDevice": "{0} е на линия от {1}",
     "UserPasswordChangedWithName": "Паролата на потребителя {0} е променена",
-    "UserPolicyUpdatedWithName": "Потребителската политика за {0} се актуализира",
     "UserStartedPlayingItemWithValues": "{0} пусна {1}",
     "UserStoppedPlayingItemWithValues": "{0} спря {1}",
-    "ValueHasBeenAddedToLibrary": "{0} беше добавен във Вашата библиотека",
-    "ValueSpecialEpisodeName": "Специални - {0}",
     "VersionNumber": "Версия {0}",
     "TaskDownloadMissingSubtitlesDescription": "Търси Интернет за липсващи субтитри, на база конфигурацията за мета-данни.",
     "TaskDownloadMissingSubtitles": "Изтегляне на липсващи субтитри",
@@ -129,8 +99,6 @@
     "TaskRefreshTrickplayImagesDescription": "Създава прегледи на Trickplay за видеа в активирани библиотеки.",
     "TaskDownloadMissingLyrics": "Свали липсващи текстове",
     "TaskDownloadMissingLyricsDescription": "Свали текстове за песни",
-    "TaskCleanCollectionsAndPlaylists": "Изчисти колекциите и плейлистите",
-    "TaskCleanCollectionsAndPlaylistsDescription": "Премахни несъществуващи файлове в колекциите и плейлистите.",
     "TaskAudioNormalization": "Нормализиране на звука",
     "TaskAudioNormalizationDescription": "Сканирай файловете за нормализация на звука.",
     "TaskExtractMediaSegmentsDescription": "Изважда медиини сегменти от MediaSegment плъгини.",

Emby.Server.Implementations/Localization/Core/bn.json

@@ -1,31 +1,19 @@
 {
-    "DeviceOnlineWithName": "{0}-এর সাথে সংযুক্ত হয়েছে",
-    "DeviceOfflineWithName": "{0}-এর সাথে সংযোগ বিচ্ছিন্ন হয়েছে",
     "Collections": "সংগ্রহশালা",
     "ChapterNameValue": "অধ্যায় {0}",
-    "Channels": "চ্যানেলসমূহ",
-    "CameraImageUploadedFrom": "{0} থেকে একটি নতুন ক্যামেরার চিত্র আপলোড করা হয়েছে",
     "Books": "পুস্তকসমূহ",
     "AuthenticationSucceededWithUserName": "{0} সফলভাবে অথেন্টিকেট করেছেন",
     "Artists": "শিল্পীগণ",
-    "Application": "অ্যাপ্লিকেশন",
-    "Albums": "অ্যালবামসমূহ",
     "HeaderFavoriteEpisodes": "প্রিয় পর্বগুলো",
-    "HeaderFavoriteArtists": "প্রিয় শিল্পীরা",
-    "HeaderFavoriteAlbums": "প্রিয় এলবামগুলো",
     "HeaderContinueWatching": "দেখতে থাকুন",
-    "HeaderAlbumArtists": "অ্যালবাম শিল্পীবৃন্দ",
     "Genres": "ধরণ",
     "Folders": "ফোল্ডারসমূহ",
     "Favorites": "পছন্দসমূহ",
     "FailedLoginAttemptWithUserName": "{0} লগিন করতে ব্যর্থ হয়েছে",
     "AppDeviceValues": "অ্যাপ: {0}, ডিভাইস: {1}",
     "VersionNumber": "সংস্করণ {0}",
-    "ValueSpecialEpisodeName": "বিশেষ পর্ব - {0}",
-    "ValueHasBeenAddedToLibrary": "আপনার লাইব্রেরিতে {0} যোগ করা হয়েছে",
     "UserStoppedPlayingItemWithValues": "{2}তে {1} প্লে শেষ করেছেন {0}",
     "UserStartedPlayingItemWithValues": "{2}তে {1} প্লে করেছেন {0}",
-    "UserPolicyUpdatedWithName": "{0} এর জন্য ব্যবহার নীতি আপডেট করা হয়েছে",
     "UserPasswordChangedWithName": "ব্যবহারকারী {0} এর পাসওয়ার্ড পরিবর্তিত হয়েছে",
     "UserOnlineFromDevice": "{0}, {1} থেকে অনলাইন আছে",
     "UserOfflineFromDevice": "{0} {1} থেকে বিচ্ছিন্ন হয়ে গেছে",
@@ -33,23 +21,14 @@
     "UserDownloadingItemWithValues": "{0}, {1} ডাউনলোড করছে",
     "UserDeletedWithName": "ব্যবহারকারী {0}কে বাদ দেয়া হয়েছে",
     "UserCreatedWithName": "ব্যবহারকারী {0} সৃষ্টি করা হয়েছে",
-    "User": "ব্যবহারকারী",
     "TvShows": "টিভি শোগুলো",
-    "System": "সিস্টেম",
-    "Sync": "সমন্বয় করুন",
     "SubtitleDownloadFailureFromForItem": "{0} থেকে {1} এর জন্য সাবটাইটেল ডাউনলোড ব্যর্থ হয়েছে",
     "StartupEmbyServerIsLoading": "জেলিফিন সার্ভার লোড হচ্ছে। দয়া করে একটু পরে আবার চেষ্টা করুন।",
-    "Songs": "সঙ্গীত সমূহ",
     "Shows": "শো সমূহ",
-    "ServerNameNeedsToBeRestarted": "{0} রিস্টার্ট করা প্রয়োজন",
-    "ScheduledTaskStartedWithName": "{0} শুরু হয়েছে",
     "ScheduledTaskFailedWithName": "{0} ব্যর্থ",
-    "ProviderValue": "প্রদানকারী: {0}",
     "PluginUpdatedWithName": "{0} আপডেট করা হয়েছে",
     "PluginUninstalledWithName": "{0} আনইন্সটল হয়েছে",
     "PluginInstalledWithName": "{0} ইন্সটল হয়েছে",
-    "Plugin": "প্লাগিন",
-    "Playlists": "প্লে লিস্ট সমূহ",
     "Photos": "ছবিসমূহ",
     "NotificationOptionVideoPlaybackStopped": "ভিডিও প্লেব্যাক বন্ধ হয়েছে",
     "NotificationOptionVideoPlayback": "ভিডিও প্লেব্যাক শুরু হয়েছে",
@@ -75,21 +54,13 @@
     "Music": "গান",
     "Movies": "চলচ্চিত্রসমূহ",
     "MixedContent": "মিশ্র কন্টেন্ট",
-    "MessageServerConfigurationUpdated": "সার্ভারের কনফিগারেশন আপডেট করা হয়েছে",
-    "HeaderRecordingGroups": "রেকর্ডিং গ্রুপগুলো",
-    "MessageNamedServerConfigurationUpdatedWithValue": "সার্ভার কনফিগারেশন সেকশন {0} আপডেট করা হয়েছে",
-    "MessageApplicationUpdatedTo": "জেলিফিন সার্ভার {0} তে আপডেট করা হয়েছে",
-    "MessageApplicationUpdated": "জেলিফিন সার্ভার আপডেট করা হয়েছে",
     "Latest": "সর্বশেষ",
     "LabelRunningTimeValue": "চলার সময়: {0}",
     "LabelIpAddressValue": "আইপি এড্রেস: {0}",
-    "ItemRemovedWithName": "{0} লাইব্রেরি থেকে বাদ দেয়া হয়েছে",
-    "ItemAddedWithName": "{0} লাইব্রেরিতে যোগ করা হয়েছে",
     "Inherit": "উত্তরাধিকারসূত্র থেকে গ্রহণ করুন",
     "HomeVideos": "হোম ভিডিও",
     "HeaderNextUp": "এরপরে আসছে",
     "HeaderLiveTV": "লাইভ টিভি",
-    "HeaderFavoriteSongs": "প্রিয় গানগুলো",
     "HeaderFavoriteShows": "প্রিয় শোগুলো",
     "TasksLibraryCategory": "লাইব্রেরি",
     "TasksMaintenanceCategory": "রক্ষণাবেক্ষণ",
@@ -127,8 +98,6 @@
     "TaskRefreshTrickplayImages": "ট্রিকপ্লে ইমেজ তৈরি",
     "TaskRefreshTrickplayImagesDescription": "সক্ষম লাইব্রেরিতে ভিডিওর জন্য ট্রিকপ্লে প্রিভিউ তৈরি করে।",
     "TaskDownloadMissingLyricsDescription": "গানের জন্য লিরিকস ডাউনলোড করুন",
-    "TaskCleanCollectionsAndPlaylists": "কালেকশন এবং প্লেলিস্ট পরিষ্কার করুন",
-    "TaskCleanCollectionsAndPlaylistsDescription": "কালেকশন এবং প্লেলিস্ট থেকে আইটেমগুলি সরিয়ে দেয় যা আর বিদ্যমান নেই।",
     "TaskExtractMediaSegments": "মিডিয়া সেগমেন্ট স্ক্যান",
     "TaskExtractMediaSegmentsDescription": "মিডিয়া সেগমেন্ট সক্ষম প্লাগইনগুলি থেকে মিডিয়া সেগমেন্ট বের করে বা অর্জন করে।",
     "TaskDownloadMissingLyrics": "অনুপস্থিত গান ডাউনলোড করুন",

Emby.Server.Implementations/Localization/Core/bs.json

@@ -0,0 +1,110 @@
+{
+    "Artists": "Umjetnici",
+    "Books": "Knjige",
+    "Collections": "Zbirke",
+    "Default": "Zadano",
+    "Favorites": "Omiljeni",
+    "Folders": "Mape",
+    "Genres": "Žanrovi",
+    "HeaderContinueWatching": "Nastavi gledati",
+    "Movies": "Filmovi",
+    "MusicVideos": "Muzički spotovi",
+    "Photos": "Slike",
+    "Shows": "Pokazuje",
+    "AppDeviceValues": "Aplikacija: {0}, Uređaj: {1}",
+    "AuthenticationSucceededWithUserName": "{0} uspješno autentificirano",
+    "ChapterNameValue": "Poglavlje {0}",
+    "External": "Vanjsko",
+    "FailedLoginAttemptWithUserName": "Neuspjeli pokušaj prijave sa {0}",
+    "Forced": "Prisilno",
+    "HeaderFavoriteEpisodes": "Omiljene epizode",
+    "HeaderFavoriteShows": "Omiljene emisije",
+    "HeaderLiveTV": "TV uživo",
+    "HeaderNextUp": "Slijedi",
+    "HearingImpaired": "Oštećen sluh",
+    "HomeVideos": "Kućni videozapisi",
+    "Inherit": "Nasljedi",
+    "LabelIpAddressValue": "IP adresa: {0}",
+    "LabelRunningTimeValue": "Trajanje: {0}",
+    "Latest": "Posljednje dodano",
+    "MixedContent": "Miješani sadržaj",
+    "Music": "Muzika",
+    "NameInstallFailed": "{0} instalacija je propala",
+    "NameSeasonNumber": "Sezona {0}",
+    "NameSeasonUnknown": "Sezona nepoznata",
+    "NewVersionIsAvailable": "Dostupna je nova verzija Jellyfin Servera za preuzimanje.",
+    "NotificationOptionApplicationUpdateAvailable": "Dostupno ažuriranje aplikacije",
+    "NotificationOptionApplicationUpdateInstalled": "Ažuriranje aplikacije instalirano",
+    "NotificationOptionAudioPlayback": "Pokrenuto je reproduciranje zvuka",
+    "NotificationOptionAudioPlaybackStopped": "Zaustavljeno je reproduciranje zvuka",
+    "NotificationOptionCameraImageUploaded": "Učitana slika s kamere",
+    "NotificationOptionInstallationFailed": "Neuspjeh instalacije",
+    "NotificationOptionNewLibraryContent": "Dodan novi sadržaj",
+    "NotificationOptionPluginError": "Neuspjeh dodatka",
+    "NotificationOptionPluginInstalled": "Dodatak je instaliran",
+    "NotificationOptionPluginUninstalled": "Dodatak je deinstaliran",
+    "NotificationOptionPluginUpdateInstalled": "Ažuriranje dodatka je instalirano",
+    "NotificationOptionServerRestartRequired": "Potreban je ponovni pokret servera",
+    "NotificationOptionTaskFailed": "Neuspjeh zakazane zadatke",
+    "NotificationOptionUserLockedOut": "Korisnik je zaključan",
+    "NotificationOptionVideoPlayback": "Pokrenuto je reproduciranje videa",
+    "NotificationOptionVideoPlaybackStopped": "Reprodukcija videa je zaustavljena",
+    "PluginInstalledWithName": "{0} je instaliran",
+    "PluginUninstalledWithName": "{0} je deinstaliran",
+    "PluginUpdatedWithName": "{0} je ažurirano",
+    "ScheduledTaskFailedWithName": "{0} nije uspjelo",
+    "StartupEmbyServerIsLoading": "Jellyfin Server se učitava. Molimo pokušajte ponovo za kratko vrijeme.",
+    "SubtitleDownloadFailureFromForItem": "Podtitlovi nisu uspjeli preuzeti sa {0} za {1}",
+    "TvShows": "TV serije",
+    "Undefined": "Nedefinirano",
+    "UserCreatedWithName": "Korisnik {0} je kreiran",
+    "UserDeletedWithName": "Korisnik {0} je izbrisan",
+    "UserDownloadingItemWithValues": "{0} preuzima {1}",
+    "UserLockedOutWithName": "Korisnik {0} je zaključan",
+    "UserOfflineFromDevice": "{0} se odspojio od {1}",
+    "UserOnlineFromDevice": "{0} je online od {1}",
+    "UserPasswordChangedWithName": "Lozinka je promijenjena za korisnika {0}",
+    "UserStartedPlayingItemWithValues": "{0} igra protiv {1} na {2}",
+    "UserStoppedPlayingItemWithValues": "{0} je završio igru protiv {1} na {2}",
+    "VersionNumber": "Verzija {0}",
+    "TasksMaintenanceCategory": "Održavanje",
+    "TasksLibraryCategory": "Biblioteka",
+    "TasksApplicationCategory": "Prijava",
+    "TasksChannelsCategory": "Internetski kanali",
+    "TaskCleanActivityLog": "Očisti dnevnik aktivnosti",
+    "TaskCleanActivityLogDescription": "Brisanje unosa u dnevnik aktivnosti starijih od konfigurisane starosti.",
+    "TaskCleanCache": "Očistite direktorij keša",
+    "TaskCleanCacheDescription": "Brisanje keš datoteka koje sistemu više nisu potrebne.",
+    "TaskRefreshChapterImages": "Izvadi slike iz poglavlja",
+    "TaskRefreshChapterImagesDescription": "Stvara minijature za videozapise koji imaju poglavlja.",
+    "TaskAudioNormalization": "Normalizacija zvuka",
+    "TaskAudioNormalizationDescription": "Skeneriše datoteke radi podataka za normalizaciju zvuka.",
+    "TaskRefreshLibrary": "Skenerisati medijsku biblioteku",
+    "TaskRefreshLibraryDescription": "Skenerira vašu medijsku biblioteku na nove datoteke i osvježava metapodatke.",
+    "TaskCleanLogs": "Očisti direktorij dnevnika",
+    "TaskCleanLogsDescription": "Brisanje dnevničkih datoteka starijih od {0} dana.",
+    "TaskRefreshPeople": "Osvježite ljude",
+    "TaskRefreshPeopleDescription": "Ažurira metapodatke za glumce i režisere u vašoj medijskoj biblioteci.",
+    "TaskRefreshTrickplayImages": "Generirajte Trickplay slike",
+    "TaskRefreshTrickplayImagesDescription": "Stvara pregled trik-igara za videozapise u omogućenim bibliotekama.",
+    "TaskUpdatePlugins": "Ažuriraj dodatke",
+    "TaskUpdatePluginsDescription": "Preuzima i instalira ažuriranja dodataka koji su konfigurisani da se automatski ažuriraju.",
+    "TaskCleanTranscode": "Očisti Transcode direktorij",
+    "TaskCleanTranscodeDescription": "Brisanje transkodiranih datoteka starijih od jednog dana.",
+    "TaskRefreshChannels": "Osvježi kanale",
+    "TaskRefreshChannelsDescription": "Osvježava informacije o internetskom kanalu.",
+    "TaskDownloadMissingLyrics": "Preuzmi nedostajuće tekstove",
+    "TaskDownloadMissingLyricsDescription": "Preuzmi tekstove pjesama",
+    "TaskDownloadMissingSubtitles": "Preuzmite nedostajuće titlove",
+    "TaskDownloadMissingSubtitlesDescription": "Pretražuje internet u potrazi za nedostajućim titlovima na osnovu konfiguracije metapodataka.",
+    "TaskOptimizeDatabase": "Optimizirajte bazu podataka",
+    "TaskOptimizeDatabaseDescription": "Komprimira bazu podataka i čisti slobodan prostor. Pokretanje ovog zadatka nakon skeniranja biblioteke ili izvođenja drugih promjena koje podrazumijevaju izmjene baze podataka može poboljšati performanse.",
+    "TaskKeyframeExtractor": "Izvađač ključnih sličica",
+    "TaskKeyframeExtractorDescription": "Izvlači ključne okvire iz video datoteka kako bi kreirao preciznije HLS playliste. Ovaj zadatak može trajati dugo.",
+    "TaskExtractMediaSegments": "Analiza medijskog segmenta",
+    "TaskExtractMediaSegmentsDescription": "Izvlači ili dobija medijske segmente iz dodataka koji podržavaju MediaSegment.",
+    "TaskMoveTrickplayImages": "Migracija lokacije slike Trickplay",
+    "TaskMoveTrickplayImagesDescription": "Premješta postojeće datoteke trik-igara prema postavkama biblioteke.",
+    "CleanupUserDataTask": "Zadatak čišćenja korisničkih podataka",
+    "CleanupUserDataTaskDescription": "Čisti sve korisničke podatke (stanje praćenja, status omiljenog itd.) sa medija koji više nije prisutan najmanje 90 dana."
+}

Emby.Server.Implementations/Localization/Core/ca.json

@@ -1,41 +1,24 @@
 {
-    "Albums": "Àlbums",
     "AppDeviceValues": "Aplicació: {0}, Dispositiu: {1}",
-    "Application": "Aplicació",
     "Artists": "Artistes",
     "AuthenticationSucceededWithUserName": "{0} s'ha autenticat correctament",
     "Books": "Llibres",
-    "CameraImageUploadedFrom": "S'ha pujat una nova imatge de càmera des de {0}",
-    "Channels": "Canals",
     "ChapterNameValue": "Capítol {0}",
     "Collections": "Col·leccions",
-    "DeviceOfflineWithName": "{0} s'ha desconnectat",
-    "DeviceOnlineWithName": "{0} està connectat",
     "FailedLoginAttemptWithUserName": "Intent de connexió fallit des de {0}",
     "Favorites": "Preferits",
     "Folders": "Directoris",
     "Genres": "Gèneres",
-    "HeaderAlbumArtists": "Artistes de l'àlbum",
     "HeaderContinueWatching": "Continueu mirant",
-    "HeaderFavoriteAlbums": "Àlbums preferits",
-    "HeaderFavoriteArtists": "Artistes preferits",
     "HeaderFavoriteEpisodes": "Episodis preferits",
     "HeaderFavoriteShows": "Sèries preferides",
-    "HeaderFavoriteSongs": "Cançons preferides",
     "HeaderLiveTV": "TV en directe",
     "HeaderNextUp": "A continuació",
-    "HeaderRecordingGroups": "Grups musicals",
     "HomeVideos": "Vídeos domèstics",
     "Inherit": "Heretat",
-    "ItemAddedWithName": "{0} s'ha afegit a la mediateca",
-    "ItemRemovedWithName": "{0} s'ha eliminat de la mediateca",
     "LabelIpAddressValue": "Adreça IP: {0}",
     "LabelRunningTimeValue": "Temps en marxa: {0}",
     "Latest": "Darrers",
-    "MessageApplicationUpdated": "El servidor de Jellyfin ha estat actualitzat",
-    "MessageApplicationUpdatedTo": "El servidor de Jellyfin ha estat actualitzat a {0}",
-    "MessageNamedServerConfigurationUpdatedWithValue": "La secció {0} de la configuració del servidor ha estat actualitzada",
-    "MessageServerConfigurationUpdated": "S'ha actualitzat la configuració del servidor",
     "MixedContent": "Contingut barrejat",
     "Movies": "Pel·lícules",
     "Music": "Música",
@@ -61,24 +44,14 @@
     "NotificationOptionVideoPlayback": "Reproducció de vídeo iniciada",
     "NotificationOptionVideoPlaybackStopped": "Reproducció de vídeo aturada",
     "Photos": "Fotos",
-    "Playlists": "Llistes de reproducció",
+    "PluginInstalledWithName": "S'ha instal·lat {0}",
-    "Plugin": "Complement",
+    "PluginUninstalledWithName": "S'ha desinstal·lat {0}",
-    "PluginInstalledWithName": "{0} ha estat instal·lat",
-    "PluginUninstalledWithName": "S'ha instal·lat {0}",
     "PluginUpdatedWithName": "S'ha actualitzat {0}",
-    "ProviderValue": "Proveïdor: {0}",
     "ScheduledTaskFailedWithName": "{0} ha fallat",
-    "ScheduledTaskStartedWithName": "S'ha iniciat {0}",
-    "ServerNameNeedsToBeRestarted": "S'ha de reiniciar {0}",
     "Shows": "Sèries",
-    "Songs": "Cançons",
     "StartupEmbyServerIsLoading": "El servidor de Jellyfin s'està carregant. Proveu-ho de nou en una estona.",
-    "SubtitleDownloadFailureForItem": "Subtitles failed to download for {0}",
     "SubtitleDownloadFailureFromForItem": "Els subtítols per a {1} no s'han pogut baixar de {0}",
-    "Sync": "Sincronitza",
-    "System": "Sistema",
     "TvShows": "Sèries de TV",
-    "User": "Usuari",
     "UserCreatedWithName": "S'ha creat l'usuari {0}",
     "UserDeletedWithName": "S'ha eliminat l'usuari {0}",
     "UserDownloadingItemWithValues": "{0} està descarregant {1}",
@@ -86,11 +59,8 @@
     "UserOfflineFromDevice": "{0} s'ha desconnectat de {1}",
     "UserOnlineFromDevice": "{0} està connectat des de {1}",
     "UserPasswordChangedWithName": "S'ha canviat la contrasenya per a l'usuari {0}",
-    "UserPolicyUpdatedWithName": "La política d'usuari s'ha actualitzat per a {0}",
     "UserStartedPlayingItemWithValues": "{0} ha començat a reproduir {1} a {2}",
     "UserStoppedPlayingItemWithValues": "{0} ha parat de reproduir {1} a {2}",
-    "ValueHasBeenAddedToLibrary": "S'ha afegit {0} a la mediateca",
-    "ValueSpecialEpisodeName": "Especial - {0}",
     "VersionNumber": "Versió {0}",
     "TaskDownloadMissingSubtitlesDescription": "Cerca a internet els subtítols que faltin a partir de la configuració de metadades.",
     "TaskDownloadMissingSubtitles": "Descàrrega dels subtítols que faltin",
@@ -105,7 +75,7 @@
     "TaskCleanLogsDescription": "Esborra els registres que tinguin més de {0} dies.",
     "TaskCleanLogs": "Neteja dels registres",
     "TaskRefreshLibraryDescription": "Escaneja les mediateques, a la cerca de fitxers nous i refresca les metadades.",
-    "TaskRefreshLibrary": "Escaneig de les mediateques",
+    "TaskRefreshLibrary": "Escaneja la mediateca",
     "TaskRefreshChapterImagesDescription": "Creació de les miniatures dels vídeos que tinguin capítols.",
     "TaskRefreshChapterImages": "Extracció de les imatges dels capítols",
     "TaskCleanCacheDescription": "Eliminació de la memòria cau no necessària per al servidor.",
@@ -127,8 +97,6 @@
     "HearingImpaired": "Discapacitat auditiva",
     "TaskRefreshTrickplayImages": "Generació d'imatges de previsualització",
     "TaskRefreshTrickplayImagesDescription": "Creació d'imatges de previsualització per a vídeos en les mediateques habilitades.",
-    "TaskCleanCollectionsAndPlaylistsDescription": "Esborra elements de col·leccions i llistes de reproducció que ja no existeixen.",
-    "TaskCleanCollectionsAndPlaylists": "Neteja de les col·leccions i llistes de reproducció",
     "TaskAudioNormalization": "Estabilització de l'àudio",
     "TaskAudioNormalizationDescription": "Escaneja els fitxer per a obtenir dades de normalització de l'àudio.",
     "TaskDownloadMissingLyricsDescription": "Descàrrega de les lletres de les cançons",
@@ -138,5 +106,6 @@
     "TaskMoveTrickplayImages": "Migració de la ubicació de la imatge de previsualització",
     "TaskMoveTrickplayImagesDescription": "Mou els fitxers existents d'imatges de previsualització segons la configuració de la mediateca.",
     "CleanupUserDataTaskDescription": "Neteja totes les dades d'usuari (estat de la visualització, estat dels preferits, etc.) del contingut multimèdia que no ha estat present durant almenys 90 dies.",
-    "CleanupUserDataTask": "Tasca de neteja de dades d'usuari"
+    "CleanupUserDataTask": "Tasca de neteja de dades d'usuari",
+    "Original": "Original"
 }

Emby.Server.Implementations/Localization/Core/chr.json

@@ -1,44 +1,30 @@
 {
     "ChapterNameValue": "Didanedi {0}",
-    "HeaderAlbumArtists": "Didanidanolisgisgi",
-    "HeaderFavoriteAlbums": "Dvganidi didanidisgisgi",
     "HeaderLiveTV": "Anigadi didanidisgosgi",
-    "HeaderRecordingGroups": "Didanisquodiisgisgi",
     "HomeVideos": "Diganadi dinagadisgisgi",
     "Inherit": "Anigwe",
-    "MessageApplicationUpdatedTo": "Tsenigwidinonvhi Jellyfin Server tsadanidigwe anigadi {0}",
     "MixedContent": "Ganinidi dininoladisgisgi",
     "Movies": "Anidvnisgisgi",
     "MusicVideos": "Danodisgisgi didanidisgosgi",
     "NotificationOptionAudioPlayback": "Didanidigwe diganuyisgisgi anigadi",
     "NotificationOptionInstallationFailed": "Diudvdi anadvnatisgisgi",
     "NotificationOptionPluginUninstalled": "Ditsigvhnidv anawvdisgisgi",
-    "Albums": "Anigawidaniyv",
-    "Application": "Didanvyi",
     "Artists": "Dinidaniyi",
     "AuthenticationSucceededWithUserName": "{0} Sesoquonisdi nagadani",
     "Books": "Didanedi",
-    "CameraImageUploadedFrom": "Anigawidaniyv nasgi didagwalanvyi {0}",
-    "Channels": "Diganadasgi",
     "Collections": "Diganadisgi",
     "Default": "Dinadi",
-    "DeviceOfflineWithName": "{0} Aniyvolehvi nasgi",
     "External": "Amohdi",
     "Favorites": "Nvdayelvdisgi",
     "Folders": "Didanididisgi",
     "Forced": "Ganedi",
     "Genres": "Diganadisgi",
     "HeaderContinueWatching": "Uwoditsu asdanidisgisgi",
-    "HeaderFavoriteArtists": "Dvganidi dinidanolisgisgi",
     "HeaderFavoriteEpisodes": "Dvganidi didanidilisgadisgisgi",
     "HeaderFavoriteShows": "Dvganidi didanididanolisgisgi)",
-    "HeaderFavoriteSongs": "Dvganidi danodisgisgi",
     "HeaderNextUp": "Anidvli uwodoli",
     "HearingImpaired": "Anitsunidi talunidisgisgi",
-    "ItemAddedWithName": "{0} Dinigwe anididanidisgi",
     "Latest": "Uwodoli",
-    "MessageApplicationUpdated": "Tsenigwidinonvhi Jellyfin Server tsadanidigwe",
-    "MessageServerConfigurationUpdated": "Sedanidvdi anigadi diganidinonvhi",
     "Music": "Danodisgisgi",
     "NameSeasonUnknown": "Tsunita anidvdisgi",
     "NewVersionIsAvailable": "Danodigwe anigadi Jellyfin Server tsadanidigwe adisdi uwodvdi diganidinonvhi.",

Emby.Server.Implementations/Localization/Core/cs.json

@@ -1,41 +1,24 @@
 {
-    "Albums": "Alba",
     "AppDeviceValues": "Aplikace: {0}, Zařízení: {1}",
-    "Application": "Aplikace",
     "Artists": "Umělci",
     "AuthenticationSucceededWithUserName": "{0} úspěšně ověřen",
     "Books": "Knihy",
-    "CameraImageUploadedFrom": "Z {0} byla nahrána nová fotografie z fotoaparátu",
-    "Channels": "Kanály",
     "ChapterNameValue": "Kapitola {0}",
     "Collections": "Kolekce",
-    "DeviceOfflineWithName": "{0} se odpojil",
-    "DeviceOnlineWithName": "{0} je připojen",
     "FailedLoginAttemptWithUserName": "Neúspěšný pokus o přihlášení z {0}",
     "Favorites": "Oblíbené",
     "Folders": "Složky",
     "Genres": "Žánry",
-    "HeaderAlbumArtists": "Umělci alba",
     "HeaderContinueWatching": "Pokračovat ve sledování",
-    "HeaderFavoriteAlbums": "Oblíbená alba",
-    "HeaderFavoriteArtists": "Oblíbení interpreti",
     "HeaderFavoriteEpisodes": "Oblíbené epizody",
     "HeaderFavoriteShows": "Oblíbené seriály",
-    "HeaderFavoriteSongs": "Oblíbená hudba",
     "HeaderLiveTV": "TV vysílání",
     "HeaderNextUp": "Další díly",
-    "HeaderRecordingGroups": "Skupiny nahrávek",
     "HomeVideos": "Domácí videa",
     "Inherit": "Zdědit",
-    "ItemAddedWithName": "{0} byl přidán do knihovny",
-    "ItemRemovedWithName": "{0} byl odstraněn z knihovny",
     "LabelIpAddressValue": "IP adresa: {0}",
     "LabelRunningTimeValue": "Délka média: {0}",
     "Latest": "Nejnovější",
-    "MessageApplicationUpdated": "Jellyfin Server byl aktualizován",
-    "MessageApplicationUpdatedTo": "Jellyfin server byl aktualizován na verzi {0}",
-    "MessageNamedServerConfigurationUpdatedWithValue": "Konfigurace sekce {0} na serveru byla aktualizována",
-    "MessageServerConfigurationUpdated": "Konfigurace serveru aktualizována",
     "MixedContent": "Smíšený obsah",
     "Movies": "Filmy",
     "Music": "Hudba",
@@ -61,24 +44,14 @@
     "NotificationOptionVideoPlayback": "Přehrávání videa zahájeno",
     "NotificationOptionVideoPlaybackStopped": "Přehrávání videa ukončeno",
     "Photos": "Fotky",
-    "Playlists": "Seznamy skladeb",
-    "Plugin": "Zásuvný modul",
     "PluginInstalledWithName": "{0} byl nainstalován",
     "PluginUninstalledWithName": "{0} byl odinstalován",
     "PluginUpdatedWithName": "{0} byl aktualizován",
-    "ProviderValue": "Poskytl: {0}",
     "ScheduledTaskFailedWithName": "{0} selhalo",
-    "ScheduledTaskStartedWithName": "{0} zahájeno",
-    "ServerNameNeedsToBeRestarted": "{0} vyžaduje restart",
     "Shows": "Seriály",
-    "Songs": "Skladby",
     "StartupEmbyServerIsLoading": "Jellyfin Server je spouštěn. Zkuste to prosím v brzké době znovu.",
-    "SubtitleDownloadFailureForItem": "Stahování titulků selhalo pro {0}",
     "SubtitleDownloadFailureFromForItem": "Stažení titulků pro {1} z {0} selhalo",
-    "Sync": "Synchronizace",
-    "System": "Systém",
     "TvShows": "Seriály",
-    "User": "Uživatel",
     "UserCreatedWithName": "Uživatel {0} byl vytvořen",
     "UserDeletedWithName": "Uživatel {0} byl smazán",
     "UserDownloadingItemWithValues": "{0} stahuje {1}",
@@ -86,11 +59,8 @@
     "UserOfflineFromDevice": "{0} se odpojil ze zařízení {1}",
     "UserOnlineFromDevice": "{0} se připojil ze zařízení {1}",
     "UserPasswordChangedWithName": "Provedena změna hesla pro uživatele {0}",
-    "UserPolicyUpdatedWithName": "Zásady uživatele pro {0} byly aktualizovány",
     "UserStartedPlayingItemWithValues": "{0} spustil přehrávání {1}",
     "UserStoppedPlayingItemWithValues": "{0} zastavil přehrávání {1}",
-    "ValueHasBeenAddedToLibrary": "{0} byl přidán do vaší knihovny médií",
-    "ValueSpecialEpisodeName": "Speciál - {0}",
     "VersionNumber": "Verze {0}",
     "TaskDownloadMissingSubtitlesDescription": "Vyhledá na internetu chybějící titulky na základě nastavení metadat.",
     "TaskDownloadMissingSubtitles": "Stáhnout chybějící titulky",
@@ -127,8 +97,6 @@
     "HearingImpaired": "Sluchově postižení",
     "TaskRefreshTrickplayImages": "Generovat obrázky pro Trickplay",
     "TaskRefreshTrickplayImagesDescription": "Obrázky Trickplay se používají k zobrazení náhledů u videí v knihovnách, kde je to povoleno.",
-    "TaskCleanCollectionsAndPlaylists": "Pročistit kolekce a seznamy přehrávání",
-    "TaskCleanCollectionsAndPlaylistsDescription": "Odstraní neexistující položky z kolekcí a seznamů přehrávání.",
     "TaskAudioNormalization": "Normalizace zvuku",
     "TaskAudioNormalizationDescription": "Skenovat soubory za účelem normalizace zvuku.",
     "TaskDownloadMissingLyrics": "Stáhnout chybějící texty k písni",
@@ -138,5 +106,6 @@
     "TaskMoveTrickplayImages": "Přesunout úložiště obrázků Trickplay",
     "TaskMoveTrickplayImagesDescription": "Přesune existující soubory Trickplay podle nastavení knihovny.",
     "CleanupUserDataTaskDescription": "Odstraní všechna uživatelská data (stav zhlédnutí, oblíbené atd.) z médií, které již neexistují více než 90 dní.",
-    "CleanupUserDataTask": "Pročistit uživatelská data"
+    "CleanupUserDataTask": "Pročistit uživatelská data",
+    "Original": "Originál"
 }

Emby.Server.Implementations/Localization/Core/cy.json

@@ -1,16 +1,11 @@
 {
-    "DeviceOnlineWithName": "Mae {0} wedi'i gysylltu",
-    "DeviceOfflineWithName": "Mae {0} wedi datgysylltu",
     "Default": "Diofyn",
     "Collections": "Casgliadau",
     "ChapterNameValue": "Pennod {0}",
-    "Channels": "Sianeli",
-    "CameraImageUploadedFrom": "Mae delwedd camera newydd wedi'i lanlwytho o {0}",
     "Books": "Llyfrau",
     "AuthenticationSucceededWithUserName": "{0} wedi’i ddilysu’n llwyddiannus",
-    "Artists": "Artistiaid",
+    "Artists": "Crewyr",
     "AppDeviceValues": "Ap: {0}, Dyfais: {1}",
-    "Albums": "Albwmau",
     "Genres": "Genres",
     "Folders": "Ffolderi",
     "Favorites": "Ffefrynnau",
@@ -20,9 +15,7 @@
     "TaskRefreshPeople": "Adnewyddu Pobl",
     "TasksChannelsCategory": "Sianeli Internet",
     "VersionNumber": "Fersiwn {0}",
-    "ScheduledTaskStartedWithName": "{0} wedi dechrau",
     "ScheduledTaskFailedWithName": "{0} wedi methu",
-    "ProviderValue": "Darparwr: {0}",
     "NotificationOptionInstallationFailed": "Fethu Gosod",
     "NameSeasonUnknown": "Tymor Anhysbys",
     "NameSeasonNumber": "Tymor {0}",
@@ -30,31 +23,20 @@
     "MixedContent": "Cynnwys amrywiol",
     "HomeVideos": "Genres",
     "HeaderNextUp": "Nesaf i Fyny",
-    "HeaderFavoriteArtists": "Ffefryn Artistiaid",
-    "HeaderFavoriteAlbums": "Ffefryn Albwmau",
     "HeaderContinueWatching": "Parhewch i Wylio",
     "TasksApplicationCategory": "Rhaglen",
     "TasksLibraryCategory": "Llyfrgell",
     "TasksMaintenanceCategory": "Cynnal a Chadw",
-    "System": "System",
-    "Plugin": "Ategyn",
     "Music": "Cerddoriaeth",
     "Latest": "Diweddaraf",
     "Inherit": "Etifeddu",
     "Forced": "Orfodi",
-    "Application": "Rhaglen",
-    "HeaderAlbumArtists": "Artistiaid albwm",
-    "Sync": "Cysoni",
-    "Songs": "Caneuon",
     "Shows": "Rhaglenni",
-    "Playlists": "Rhestri Chwarae",
     "Photos": "Lluniau",
-    "ValueSpecialEpisodeName": "Arbennig - {0}",
     "Movies": "Ffilmiau",
     "Undefined": "Heb ddiffiniad",
     "TvShows": "Rhaglenni teledu",
     "HeaderLiveTV": "Teledu Byw",
-    "User": "Defnyddiwr",
     "TaskCleanLogsDescription": "Dileu ffeiliau log sy'n fwy na {0} diwrnod oed.",
     "TaskCleanLogs": "Glanhau ffolder log",
     "TaskRefreshLibraryDescription": "Sganio'ch llyfrgell gyfryngau am ffeiliau newydd ac yn adnewyddu metaddata.",
@@ -65,13 +47,9 @@
     "NotificationOptionPluginError": "Methodd ategyn",
     "NotificationOptionAudioPlaybackStopped": "Stopiwyd chwarae sain",
     "NotificationOptionAudioPlayback": "Dechreuwyd chwarae sain",
-    "MessageServerConfigurationUpdated": "Mae gosodiadau gweinydd wedi'i ddiweddaru",
+    "FailedLoginAttemptWithUserName": "Cais mewngofnodi wedi methu o {0}",
-    "MessageNamedServerConfigurationUpdatedWithValue": "Mae adran gosodiadau gweinydd {0} wedi'i diweddaru",
-    "FailedLoginAttemptWithUserName": "Cais mewngofnodi wedi methu gan {0}",
-    "ValueHasBeenAddedToLibrary": "{0} wedi'i hychwanegu at eich llyfrgell gyfryngau",
     "UserStoppedPlayingItemWithValues": "{0} wedi gorffen chwarae {1} ar {2}",
     "UserStartedPlayingItemWithValues": "{0} yn chwarae {1} ar {2}",
-    "UserPolicyUpdatedWithName": "Polisi defnyddiwr wedi'i newid ar gyfer {0}",
     "UserPasswordChangedWithName": "Cyfrinair wedi'i newid ar gyfer defnyddiwr {0}",
     "UserOnlineFromDevice": "Mae {0} ar-lein o {1}",
     "UserOfflineFromDevice": "Mae {0} wedi datgysylltu o {1}",
@@ -80,7 +58,6 @@
     "UserDeletedWithName": "Defnyddiwr {0} wedi'i ddileu",
     "UserCreatedWithName": "Defnyddiwr {0} wedi'i greu",
     "StartupEmbyServerIsLoading": "Gweinydd Jellyfin yn llwytho. Triwch eto mewn ychydig.",
-    "ServerNameNeedsToBeRestarted": "Mae angen ailddechrau {0}",
     "PluginUpdatedWithName": "{0} wedi'i ddiweddaru",
     "PluginUninstalledWithName": "{0} wedi'i ddadosod",
     "PluginInstalledWithName": "{0} wedi'i osod",
@@ -98,13 +75,7 @@
     "NotificationOptionApplicationUpdateAvailable": "Diweddariad ap ar gael",
     "NewVersionIsAvailable": "Mae fersiwn diweddarach o'r gweinydd Jellyfin ar gael.",
     "NameInstallFailed": "Gosodiad {0} wedi methu",
-    "MessageApplicationUpdatedTo": "Gweinydd Jellyfin wedi'i ddiweddaru i {0}",
-    "MessageApplicationUpdated": "Gweinydd Jellyfin wedi'i ddiweddaru",
     "LabelIpAddressValue": "Cyfeiriad IP: {0}",
-    "ItemRemovedWithName": "{0} wedi'i dynnu o'r llyfrgell",
-    "ItemAddedWithName": "{0} wedi'i adio i'r llyfrgell",
-    "HeaderRecordingGroups": "Grwpiau Recordio",
-    "HeaderFavoriteSongs": "Ffefryn Ganeuon",
     "HeaderFavoriteShows": "Ffefryn Shoeau",
     "HeaderFavoriteEpisodes": "Ffefryn Rhaglenni",
     "TaskDownloadMissingSubtitlesDescription": "Chwilio'r rhyngrwyd am is-deitlau coll yn seiliedig ar gosodiadau metaddata.",
@@ -123,5 +94,12 @@
     "TaskRefreshChapterImages": "Echdynnu Lluniau Pennod",
     "TaskCleanCacheDescription": "Dileu ffeiliau cache nad oes eu hangen ar y system mwyach.",
     "TaskCleanCache": "Gwaghau Ffolder Cache",
-    "HearingImpaired": "Nam ar y clyw"
+    "HearingImpaired": "Nam ar y clyw",
+    "TaskAudioNormalization": "Gwastatau Sain",
+    "TaskAudioNormalizationDescription": "Yn sganio ffeiliau am ddata gwastatau sain.",
+    "TaskRefreshTrickplayImages": "Creuwch lluniau Trickplay",
+    "TaskRefreshTrickplayImagesDescription": "Creu rhagolygon Trickplay ar gyfer fideos mewn llyfrgelloedd gweithredol.",
+    "TaskDownloadMissingLyrics": "Lawrlwytho geiriau coll",
+    "TaskDownloadMissingLyricsDescription": "Lawrlwytho geiriau caneuon",
+    "TaskExtractMediaSegments": "Sganio Darnau Cyfryngau"
 }

Emby.Server.Implementations/Localization/Core/da.json

@@ -1,41 +1,24 @@
 {
-    "Albums": "Albummer",
     "AppDeviceValues": "App: {0}, Enhed: {1}",
-    "Application": "Applikation",
     "Artists": "Kunstnere",
     "AuthenticationSucceededWithUserName": "{0} er logget ind",
     "Books": "Bøger",
-    "CameraImageUploadedFrom": "Et nyt kamerabillede er blevet uploadet fra {0}",
-    "Channels": "Kanaler",
     "ChapterNameValue": "Kapitel {0}",
     "Collections": "Samlinger",
-    "DeviceOfflineWithName": "{0} har afbrudt forbindelsen",
-    "DeviceOnlineWithName": "{0} er forbundet",
     "FailedLoginAttemptWithUserName": "Mislykket loginforsøg fra {0}",
     "Favorites": "Favoritter",
     "Folders": "Mapper",
     "Genres": "Genrer",
-    "HeaderAlbumArtists": "Albumkunstnere",
     "HeaderContinueWatching": "Fortsæt afspilning",
-    "HeaderFavoriteAlbums": "Favoritalbum",
-    "HeaderFavoriteArtists": "Favoritkunstnere",
     "HeaderFavoriteEpisodes": "Yndlingsafsnit",
     "HeaderFavoriteShows": "Yndlingsserier",
-    "HeaderFavoriteSongs": "Yndlingssange",
     "HeaderLiveTV": "Live-TV",
     "HeaderNextUp": "Næste",
-    "HeaderRecordingGroups": "Optagelsesgrupper",
     "HomeVideos": "Hjemmevideoer",
     "Inherit": "Nedarv",
-    "ItemAddedWithName": "{0} blev tilføjet til biblioteket",
-    "ItemRemovedWithName": "{0} blev fjernet fra biblioteket",
     "LabelIpAddressValue": "IP-adresse: {0}",
     "LabelRunningTimeValue": "Spilletid: {0}",
     "Latest": "Seneste",
-    "MessageApplicationUpdated": "Jellyfin Server er blevet opdateret",
-    "MessageApplicationUpdatedTo": "Jellyfin Server er blevet opdateret til {0}",
-    "MessageNamedServerConfigurationUpdatedWithValue": "Serverkonfiguration sektion {0} er blevet opdateret",
-    "MessageServerConfigurationUpdated": "Serverkonfigurationen er blevet opdateret",
     "MixedContent": "Blandet indhold",
     "Movies": "Film",
     "Music": "Musik",
@@ -61,24 +44,14 @@
     "NotificationOptionVideoPlayback": "Videoafspilning påbegyndt",
     "NotificationOptionVideoPlaybackStopped": "Videoafspilning blev stoppet",
     "Photos": "Fotos",
-    "Playlists": "Afspilningslister",
-    "Plugin": "Plugin",
     "PluginInstalledWithName": "{0} blev installeret",
     "PluginUninstalledWithName": "{0} blev afinstalleret",
     "PluginUpdatedWithName": "{0} blev opdateret",
-    "ProviderValue": "Udbyder: {0}",
     "ScheduledTaskFailedWithName": "{0} mislykkedes",
-    "ScheduledTaskStartedWithName": "{0} påbegyndte",
-    "ServerNameNeedsToBeRestarted": "{0} skal genstartes",
     "Shows": "Serier",
-    "Songs": "Sange",
     "StartupEmbyServerIsLoading": "Jellyfin er i gang med at starte. Prøv igen om et øjeblik.",
-    "SubtitleDownloadFailureForItem": "Fejlet i download af undertekster for {0}",
     "SubtitleDownloadFailureFromForItem": "Undertekster kunne ikke hentes fra {0} til {1}",
-    "Sync": "Synkroniser",
-    "System": "System",
     "TvShows": "TV-serier",
-    "User": "Bruger",
     "UserCreatedWithName": "Bruger {0} er blevet oprettet",
     "UserDeletedWithName": "Brugeren {0} er nu slettet",
     "UserDownloadingItemWithValues": "{0} henter {1}",
@@ -86,11 +59,8 @@
     "UserOfflineFromDevice": "{0} har afbrudt fra {1}",
     "UserOnlineFromDevice": "{0} er online fra {1}",
     "UserPasswordChangedWithName": "Adgangskode er ændret for brugeren {0}",
-    "UserPolicyUpdatedWithName": "Brugerpolitikken er blevet opdateret for {0}",
     "UserStartedPlayingItemWithValues": "{0} afspiller {1} på {2}",
     "UserStoppedPlayingItemWithValues": "{0} har afsluttet afspilning af {1} på {2}",
-    "ValueHasBeenAddedToLibrary": "{0} er blevet tilføjet til dit mediebibliotek",
-    "ValueSpecialEpisodeName": "Special - {0}",
     "VersionNumber": "Version {0}",
     "TaskDownloadMissingSubtitlesDescription": "Søger på internettet efter manglende undertekster baseret på metadata-konfigurationen.",
     "TaskDownloadMissingSubtitles": "Hent manglende undertekster",
@@ -127,8 +97,6 @@
     "HearingImpaired": "Hørehæmmet",
     "TaskRefreshTrickplayImages": "Generer trickplay-billeder",
     "TaskRefreshTrickplayImagesDescription": "Laver trickplay-billeder for videoer i aktiverede biblioteker.",
-    "TaskCleanCollectionsAndPlaylists": "Ryd op i samlinger og afspilningslister",
-    "TaskCleanCollectionsAndPlaylistsDescription": "Fjerner elementer fra samlinger og afspilningslister der ikke eksisterer længere.",
     "TaskAudioNormalizationDescription": "Skanner filer for data vedrørende lydnormalisering.",
     "TaskAudioNormalization": "Lydnormalisering",
     "TaskDownloadMissingLyricsDescription": "Søger på internettet efter manglende sangtekster baseret på metadata-konfigurationen",

Emby.Server.Implementations/Localization/Core/de.json

@@ -1,41 +1,24 @@
 {
-    "Albums": "Alben",
     "AppDeviceValues": "App: {0}, Gerät: {1}",
-    "Application": "Anwendung",
     "Artists": "Interpreten",
     "AuthenticationSucceededWithUserName": "{0} erfolgreich authentifiziert",
     "Books": "Bücher",
-    "CameraImageUploadedFrom": "Ein neues Kamerabild wurde von {0} hochgeladen",
-    "Channels": "Kanäle",
     "ChapterNameValue": "Kapitel {0}",
     "Collections": "Sammlungen",
-    "DeviceOfflineWithName": "{0} hat die Verbindung getrennt",
+    "FailedLoginAttemptWithUserName": "Anmeldung von {0} fehlgeschlagen",
-    "DeviceOnlineWithName": "{0} ist verbunden",
-    "FailedLoginAttemptWithUserName": "Fehlgeschlagener Anmeldeversuch von {0}",
     "Favorites": "Favoriten",
     "Folders": "Verzeichnisse",
     "Genres": "Genres",
-    "HeaderAlbumArtists": "Album-Interpreten",
     "HeaderContinueWatching": "Weiterschauen",
-    "HeaderFavoriteAlbums": "Lieblingsalben",
+    "HeaderFavoriteEpisodes": "Lieblingsfolgen",
-    "HeaderFavoriteArtists": "Lieblingsinterpreten",
-    "HeaderFavoriteEpisodes": "Lieblingsepisoden",
     "HeaderFavoriteShows": "Lieblingsserien",
-    "HeaderFavoriteSongs": "Lieblingslieder",
     "HeaderLiveTV": "Live TV",
     "HeaderNextUp": "Als Nächstes",
-    "HeaderRecordingGroups": "Aufnahme-Gruppen",
     "HomeVideos": "Heimvideos",
     "Inherit": "Vererben",
-    "ItemAddedWithName": "{0} wurde der Bibliothek hinzugefügt",
-    "ItemRemovedWithName": "{0} wurde aus der Bibliothek entfernt",
     "LabelIpAddressValue": "IP-Adresse: {0}",
     "LabelRunningTimeValue": "Laufzeit: {0}",
     "Latest": "Neueste",
-    "MessageApplicationUpdated": "Jellyfin-Server wurde aktualisiert",
-    "MessageApplicationUpdatedTo": "Jellyfin-Server wurde auf Version {0} aktualisiert",
-    "MessageNamedServerConfigurationUpdatedWithValue": "Der Server-Einstellungsbereich {0} wurde aktualisiert",
-    "MessageServerConfigurationUpdated": "Servereinstellungen wurden aktualisiert",
     "MixedContent": "Gemischte Inhalte",
     "Movies": "Filme",
     "Music": "Musik",
@@ -46,7 +29,7 @@
     "NewVersionIsAvailable": "Eine neue Jellyfin-Serverversion steht zum Download bereit.",
     "NotificationOptionApplicationUpdateAvailable": "Anwendungsaktualisierung verfügbar",
     "NotificationOptionApplicationUpdateInstalled": "Anwendungsaktualisierung installiert",
-    "NotificationOptionAudioPlayback": "Audiowiedergabe gestartet",
+    "NotificationOptionAudioPlayback": "Audio wird abgespielt",
     "NotificationOptionAudioPlaybackStopped": "Audiowiedergabe gestoppt",
     "NotificationOptionCameraImageUploaded": "Foto hochgeladen",
     "NotificationOptionInstallationFailed": "Installation fehlgeschlagen",
@@ -57,65 +40,52 @@
     "NotificationOptionPluginUpdateInstalled": "Pluginaktualisierung installiert",
     "NotificationOptionServerRestartRequired": "Serverneustart notwendig",
     "NotificationOptionTaskFailed": "Geplante Aufgabe fehlgeschlagen",
-    "NotificationOptionUserLockedOut": "Benutzer ausgeschlossen",
+    "NotificationOptionUserLockedOut": "Benutzer gesperrt",
-    "NotificationOptionVideoPlayback": "Videowiedergabe gestartet",
+    "NotificationOptionVideoPlayback": "Video wird abgespielt",
     "NotificationOptionVideoPlaybackStopped": "Videowiedergabe gestoppt",
     "Photos": "Fotos",
-    "Playlists": "Wiedergabelisten",
-    "Plugin": "Plugin",
     "PluginInstalledWithName": "{0} wurde installiert",
     "PluginUninstalledWithName": "{0} wurde deinstalliert",
     "PluginUpdatedWithName": "{0} wurde aktualisiert",
-    "ProviderValue": "Anbieter: {0}",
     "ScheduledTaskFailedWithName": "{0} ist fehlgeschlagen",
-    "ScheduledTaskStartedWithName": "{0} wurde gestartet",
-    "ServerNameNeedsToBeRestarted": "{0} muss neu gestartet werden",
     "Shows": "Serien",
-    "Songs": "Lieder",
     "StartupEmbyServerIsLoading": "Jellyfin-Server lädt. Bitte versuche es gleich noch einmal.",
-    "SubtitleDownloadFailureForItem": "Download der Untertitel fehlgeschlagen für {0}",
     "SubtitleDownloadFailureFromForItem": "Untertitel von {0} für {1} konnten nicht heruntergeladen werden",
-    "Sync": "Synchronisation",
-    "System": "System",
     "TvShows": "Serien",
-    "User": "Benutzer",
     "UserCreatedWithName": "Benutzer {0} wurde erstellt",
     "UserDeletedWithName": "Benutzer {0} wurde gelöscht",
     "UserDownloadingItemWithValues": "{0} lädt {1} herunter",
-    "UserLockedOutWithName": "Benutzer {0} wurde ausgeschlossen",
+    "UserLockedOutWithName": "Benutzer {0} wurde gesperrt",
     "UserOfflineFromDevice": "{0} wurde getrennt von {1}",
     "UserOnlineFromDevice": "{0} ist online von {1}",
     "UserPasswordChangedWithName": "Das Passwort für Benutzer {0} wurde geändert",
-    "UserPolicyUpdatedWithName": "Benutzerrichtlinie von {0} wurde aktualisiert",
     "UserStartedPlayingItemWithValues": "{0} hat die Wiedergabe von {1} auf {2} gestartet",
     "UserStoppedPlayingItemWithValues": "{0} hat die Wiedergabe von {1} auf {2} beendet",
-    "ValueHasBeenAddedToLibrary": "{0} wurde deiner Bibliothek hinzugefügt",
-    "ValueSpecialEpisodeName": "Extra – {0}",
     "VersionNumber": "Version {0}",
     "TaskDownloadMissingSubtitlesDescription": "Sucht im Internet basierend auf den Metadaten-Einstellungen nach fehlenden Untertiteln.",
     "TaskDownloadMissingSubtitles": "Fehlende Untertitel herunterladen",
     "TaskRefreshChannelsDescription": "Aktualisiert Internet-Kanal-Informationen.",
     "TaskRefreshChannels": "Kanäle aktualisieren",
     "TaskCleanTranscodeDescription": "Löscht Transkodierungsdateien, die älter als einen Tag sind.",
-    "TaskCleanTranscode": "Transkodierungs-Verzeichnis aufräumen",
+    "TaskCleanTranscode": "Transkodierungsverzeichnis leeren",
     "TaskUpdatePluginsDescription": "Lädt Updates für Plugins herunter, welche für automatische Updates konfiguriert sind und installiert diese.",
     "TaskUpdatePlugins": "Plugins aktualisieren",
     "TaskRefreshPeopleDescription": "Aktualisiert Metadaten für Schauspieler und Regisseure in deinen Bibliotheken.",
     "TaskRefreshPeople": "Personen aktualisieren",
     "TaskCleanLogsDescription": "Lösche Log-Dateien, die älter als {0} Tage sind.",
-    "TaskCleanLogs": "Log-Verzeichnis aufräumen",
+    "TaskCleanLogs": "Protokollverzeichnis leeren",
-    "TaskRefreshLibraryDescription": "Durchsucht alle Bibliotheken nach neu hinzugefügten Dateien und aktualisiert Metadaten.",
+    "TaskRefreshLibraryDescription": "Durchsucht deine Medienbibliothek nach neuen Dateien und aktualisiert Metadaten.",
     "TaskRefreshLibrary": "Medien-Bibliothek scannen",
-    "TaskRefreshChapterImagesDescription": "Erstellt Vorschaubilder für Videos, die Kapitel besitzen.",
+    "TaskRefreshChapterImagesDescription": "Erstellt Vorschaubilder für Videokapitel.",
-    "TaskRefreshChapterImages": "Kapitel-Bilder extrahieren",
+    "TaskRefreshChapterImages": "Kapitelvorschauen erstellen",
-    "TaskCleanCacheDescription": "Löscht vom System nicht mehr benötigte Zwischenspeicherdateien.",
+    "TaskCleanCacheDescription": "Löscht Cache-Dateien, die vom System nicht mehr benötigt werden.",
-    "TaskCleanCache": "Zwischenspeicher-Verzeichnis aufräumen",
+    "TaskCleanCache": "Cache-Verzeichnis leeren",
     "TasksChannelsCategory": "Internet-Kanäle",
     "TasksApplicationCategory": "Anwendung",
     "TasksLibraryCategory": "Bibliothek",
     "TasksMaintenanceCategory": "Wartung",
     "TaskCleanActivityLogDescription": "Löscht Aktivitätsprotokolleinträge, die älter als das konfigurierte Alter sind.",
-    "TaskCleanActivityLog": "Aktivitätsprotokolle aufräumen",
+    "TaskCleanActivityLog": "Aktivitätsverlauf bereinigen",
     "Undefined": "Undefiniert",
     "Forced": "Erzwungen",
     "Default": "Standard",
@@ -127,8 +97,6 @@
     "HearingImpaired": "Hörgeschädigt",
     "TaskRefreshTrickplayImages": "Trickplay-Bilder generieren",
     "TaskRefreshTrickplayImagesDescription": "Erstellt ein Trickplay-Vorschauen für Videos in aktivierten Bibliotheken.",
-    "TaskCleanCollectionsAndPlaylists": "Sammlungen und Playlisten aufräumen",
-    "TaskCleanCollectionsAndPlaylistsDescription": "Löscht nicht mehr vorhandene Einträge aus den Sammlungen und Playlisten.",
     "TaskAudioNormalization": "Audio Normalisierung",
     "TaskAudioNormalizationDescription": "Durchsucht Dateien nach Audionormalisierungsdaten.",
     "TaskDownloadMissingLyricsDescription": "Lädt Songtexte herunter",
@@ -138,5 +106,7 @@
     "TaskMoveTrickplayImages": "Verzeichnis für Trickplay-Bilder migrieren",
     "TaskMoveTrickplayImagesDescription": "Trickplay-Bilder werden entsprechend der Bibliothekseinstellungen verschoben.",
     "CleanupUserDataTask": "Aufgabe zur Bereinigung von Benutzerdaten",
-    "CleanupUserDataTaskDescription": "Löscht alle Benutzerdaten (Abspielstatus, Favoritenstatus, usw.) von Medien, die seit mindestens 90 Tagen nicht mehr vorhanden sind."
+    "CleanupUserDataTaskDescription": "Löscht alle Benutzerdaten (Abspielstatus, Favoritenstatus, usw.) von Medien, die seit mindestens 90 Tagen nicht mehr vorhanden sind.",
+    "Original": "Original",
+    "LyricDownloadFailureFromForItem": "Fehler beim Download der Songtexte von {0} für {1}"
 }

Emby.Server.Implementations/Localization/Core/el.json

@@ -1,41 +1,24 @@
 {
-    "Albums": "Άλμπουμ",
     "AppDeviceValues": "Εφαρμογή: {0}, Συσκευή: {1}",
-    "Application": "Εφαρμογή",
     "Artists": "Καλλιτέχνες",
     "AuthenticationSucceededWithUserName": "Ο χρήστης {0} επαληθεύτηκε επιτυχώς",
     "Books": "Βιβλία",
-    "CameraImageUploadedFrom": "Μια νέα φωτογραφία φορτώθηκε από {0}",
-    "Channels": "Κανάλια",
     "ChapterNameValue": "Κεφάλαιο {0}",
     "Collections": "Συλλογές",
-    "DeviceOfflineWithName": "Ο/Η {0} αποσυνδέθηκε",
-    "DeviceOnlineWithName": "Ο/Η {0} συνδέθηκε",
     "FailedLoginAttemptWithUserName": "Αποτυχία προσπάθειας σύνδεσης από {0}",
     "Favorites": "Αγαπημένα",
     "Folders": "Φάκελοι",
     "Genres": "Είδη",
-    "HeaderAlbumArtists": "Καλλιτέχνες άλμπουμ",
     "HeaderContinueWatching": "Συνεχίστε την παρακολούθηση",
-    "HeaderFavoriteAlbums": "Αγαπημένα Άλμπουμ",
-    "HeaderFavoriteArtists": "Αγαπημένοι Καλλιτέχνες",
     "HeaderFavoriteEpisodes": "Αγαπημένα Επεισόδια",
     "HeaderFavoriteShows": "Αγαπημένες Σειρές",
-    "HeaderFavoriteSongs": "Αγαπημένα Τραγούδια",
     "HeaderLiveTV": "Ζωντανή Τηλεόραση",
     "HeaderNextUp": "Επόμενο",
-    "HeaderRecordingGroups": "Ομάδες Ηχογράφησης",
     "HomeVideos": "Προσωπικά Βίντεο",
     "Inherit": "Κληρονόμηση",
-    "ItemAddedWithName": "Το {0} προστέθηκε στη βιβλιοθήκη",
-    "ItemRemovedWithName": "Το {0} διαγράφτηκε από τη βιβλιοθήκη",
     "LabelIpAddressValue": "Διεύθυνση IP: {0}",
     "LabelRunningTimeValue": "Διάρκεια: {0}",
     "Latest": "Πρόσφατα",
-    "MessageApplicationUpdated": "Ο διακομιστής Jellyfin έχει ενημερωθεί",
-    "MessageApplicationUpdatedTo": "Ο διακομιστής Jellyfin αναβαθμίστηκε στην έκδοση {0}",
-    "MessageNamedServerConfigurationUpdatedWithValue": "Η ενότητα {0} ρύθμισης παραμέτρων του διακομιστή έχει ενημερωθεί",
-    "MessageServerConfigurationUpdated": "Η ρύθμιση παραμέτρων του διακομιστή έχει ενημερωθεί",
     "MixedContent": "Ανάμεικτο Περιεχόμενο",
     "Movies": "Ταινίες",
     "Music": "Μουσική",
@@ -61,24 +44,14 @@
     "NotificationOptionVideoPlayback": "Η αναπαραγωγή βίντεο ξεκίνησε",
     "NotificationOptionVideoPlaybackStopped": "Η αναπαραγωγή βίντεο σταμάτησε",
     "Photos": "Φωτογραφίες",
-    "Playlists": "Λίστες αναπαραγωγής",
-    "Plugin": "Πρόσθετο",
     "PluginInstalledWithName": "Το {0} εγκαταστάθηκε",
     "PluginUninstalledWithName": "Το {0} έχει απεγκατασταθεί",
     "PluginUpdatedWithName": "Το {0} ενημερώθηκε",
-    "ProviderValue": "Πάροχος: {0}",
     "ScheduledTaskFailedWithName": "{0} αποτυχία",
-    "ScheduledTaskStartedWithName": "{0} ξεκίνησε",
-    "ServerNameNeedsToBeRestarted": "{0} χρειάζεται επανεκκίνηση",
     "Shows": "Σειρές",
-    "Songs": "Τραγούδια",
     "StartupEmbyServerIsLoading": "Ο διακομιστής Jellyfin φορτώνει. Περιμένετε λίγο και δοκιμάστε ξανά.",
-    "SubtitleDownloadFailureForItem": "Οι υπότιτλοι απέτυχαν να κατέβουν για {0}",
     "SubtitleDownloadFailureFromForItem": "Αποτυχίες μεταφόρτωσης υποτίτλων από {0} για {1}",
-    "Sync": "Συγχρονισμός",
-    "System": "Σύστημα",
     "TvShows": "Τηλεοπτικές Σειρές",
-    "User": "Χρήστης",
     "UserCreatedWithName": "Ο χρήστης {0} δημιουργήθηκε",
     "UserDeletedWithName": "Ο χρήστης {0} έχει διαγραφεί",
     "UserDownloadingItemWithValues": "{0} κατεβάζει {1}",
@@ -86,11 +59,8 @@
     "UserOfflineFromDevice": "{0} αποσυνδέθηκε από {1}",
     "UserOnlineFromDevice": "{0} είναι online απο {1}",
     "UserPasswordChangedWithName": "Ο κωδικός του χρήστη {0} έχει αλλάξει",
-    "UserPolicyUpdatedWithName": "Η πολιτική χρήστη έχει ενημερωθεί για {0}",
     "UserStartedPlayingItemWithValues": "{0} παίζει {1} σε {2}",
     "UserStoppedPlayingItemWithValues": "{0} τελείωσε να παίζει {1} σε {2}",
-    "ValueHasBeenAddedToLibrary": "{0} προστέθηκαν στη βιβλιοθήκη πολυμέσων σας",
-    "ValueSpecialEpisodeName": "Σπέσιαλ - {0}",
     "VersionNumber": "Έκδοση {0}",
     "TaskRefreshPeople": "Ανανέωση Ατόμων",
     "TaskCleanLogsDescription": "Διαγράφει αρχεία καταγραφής που είναι πάνω από {0} ημέρες.",
@@ -129,8 +99,6 @@
     "TaskRefreshTrickplayImagesDescription": "Δημιουργεί προεπισκοπήσεις trickplay για βίντεο σε ενεργοποιημένες βιβλιοθήκες.",
     "TaskAudioNormalization": "Ομοιομορφία ήχου",
     "TaskAudioNormalizationDescription": "Ανίχνευση αρχείων για δεδομένα ομοιομορφίας ήχου.",
-    "TaskCleanCollectionsAndPlaylists": "Καθαρισμός συλλογών και λιστών αναπαραγωγής",
-    "TaskCleanCollectionsAndPlaylistsDescription": "Αφαιρούνται στοιχεία από τις συλλογές και τις λίστες αναπαραγωγής που δεν υπάρχουν πλέον.",
     "TaskMoveTrickplayImages": "Αλλαγή τοποθεσίας εικόνων Trickplay",
     "TaskDownloadMissingLyrics": "Λήψη στίχων που λείπουν",
     "TaskMoveTrickplayImagesDescription": "Μετακινεί τα υπάρχοντα αρχεία trickplay σύμφωνα με τις ρυθμίσεις της βιβλιοθήκης.",

Emby.Server.Implementations/Localization/Core/en-GB.json

@@ -1,41 +1,24 @@
 {
-    "Albums": "Albums",
     "AppDeviceValues": "App: {0}, Device: {1}",
-    "Application": "Application",
     "Artists": "Artists",
     "AuthenticationSucceededWithUserName": "{0} successfully authenticated",
     "Books": "Books",
-    "CameraImageUploadedFrom": "A new camera image has been uploaded from {0}",
-    "Channels": "Channels",
     "ChapterNameValue": "Chapter {0}",
     "Collections": "Collections",
-    "DeviceOfflineWithName": "{0} has disconnected",
-    "DeviceOnlineWithName": "{0} is connected",
     "FailedLoginAttemptWithUserName": "Failed login attempt from {0}",
     "Favorites": "Favourites",
     "Folders": "Folders",
     "Genres": "Genres",
-    "HeaderAlbumArtists": "Album artists",
     "HeaderContinueWatching": "Continue Watching",
-    "HeaderFavoriteAlbums": "Favourite Albums",
-    "HeaderFavoriteArtists": "Favourite Artists",
     "HeaderFavoriteEpisodes": "Favourite Episodes",
     "HeaderFavoriteShows": "Favourite Shows",
-    "HeaderFavoriteSongs": "Favourite Songs",
     "HeaderLiveTV": "Live TV",
     "HeaderNextUp": "Next Up",
-    "HeaderRecordingGroups": "Recording Groups",
     "HomeVideos": "Home Videos",
     "Inherit": "Inherit",
-    "ItemAddedWithName": "{0} was added to the library",
-    "ItemRemovedWithName": "{0} was removed from the library",
     "LabelIpAddressValue": "IP address: {0}",
     "LabelRunningTimeValue": "Running time: {0}",
     "Latest": "Latest",
-    "MessageApplicationUpdated": "Jellyfin Server has been updated",
-    "MessageApplicationUpdatedTo": "Jellyfin Server has been updated to {0}",
-    "MessageNamedServerConfigurationUpdatedWithValue": "Server configuration section {0} has been updated",
-    "MessageServerConfigurationUpdated": "Server configuration has been updated",
     "MixedContent": "Mixed content",
     "Movies": "Movies",
     "Music": "Music",
@@ -61,24 +44,14 @@
     "NotificationOptionVideoPlayback": "Video playback started",
     "NotificationOptionVideoPlaybackStopped": "Video playback stopped",
     "Photos": "Photos",
-    "Playlists": "Playlists",
-    "Plugin": "Plugin",
     "PluginInstalledWithName": "{0} was installed",
     "PluginUninstalledWithName": "{0} was uninstalled",
     "PluginUpdatedWithName": "{0} was updated",
-    "ProviderValue": "Provider: {0}",
     "ScheduledTaskFailedWithName": "{0} failed",
-    "ScheduledTaskStartedWithName": "{0} started",
-    "ServerNameNeedsToBeRestarted": "{0} needs to be restarted",
     "Shows": "Shows",
-    "Songs": "Songs",
     "StartupEmbyServerIsLoading": "Jellyfin Server is loading. Please try again shortly.",
-    "SubtitleDownloadFailureForItem": "Subtitles failed to download for {0}",
     "SubtitleDownloadFailureFromForItem": "Subtitles failed to download from {0} for {1}",
-    "Sync": "Sync",
-    "System": "System",
     "TvShows": "TV Shows",
-    "User": "User",
     "UserCreatedWithName": "User {0} has been created",
     "UserDeletedWithName": "User {0} has been deleted",
     "UserDownloadingItemWithValues": "{0} is downloading {1}",
@@ -86,11 +59,8 @@
     "UserOfflineFromDevice": "{0} has disconnected from {1}",
     "UserOnlineFromDevice": "{0} is online from {1}",
     "UserPasswordChangedWithName": "Password has been changed for user {0}",
-    "UserPolicyUpdatedWithName": "User policy has been updated for {0}",
     "UserStartedPlayingItemWithValues": "{0} has started playing {1}",
     "UserStoppedPlayingItemWithValues": "{0} has finished playing {1} on {2}",
-    "ValueHasBeenAddedToLibrary": "{0} has been added to your media library",
-    "ValueSpecialEpisodeName": "Special - {0}",
     "VersionNumber": "Version {0}",
     "TaskDownloadMissingSubtitlesDescription": "Searches the internet for missing subtitles based on metadata configuration.",
     "TaskDownloadMissingSubtitles": "Download missing subtitles",
@@ -127,8 +97,6 @@
     "HearingImpaired": "Hearing Impaired",
     "TaskRefreshTrickplayImages": "Generate Trickplay Images",
     "TaskRefreshTrickplayImagesDescription": "Creates trickplay previews for videos in enabled libraries.",
-    "TaskCleanCollectionsAndPlaylists": "Clean up collections and playlists",
-    "TaskCleanCollectionsAndPlaylistsDescription": "Removes items from collections and playlists that no longer exist.",
     "TaskAudioNormalization": "Audio Normalisation",
     "TaskAudioNormalizationDescription": "Scans files for audio normalisation data.",
     "TaskDownloadMissingLyrics": "Download missing lyrics",

Emby.Server.Implementations/Localization/Core/en-US.json

@@ -1,45 +1,29 @@
 {
-    "Albums": "Albums",
     "AppDeviceValues": "App: {0}, Device: {1}",
-    "Application": "Application",
     "Artists": "Artists",
     "AuthenticationSucceededWithUserName": "{0} successfully authenticated",
     "Books": "Books",
-    "CameraImageUploadedFrom": "A new camera image has been uploaded from {0}",
-    "Channels": "Channels",
     "ChapterNameValue": "Chapter {0}",
     "Collections": "Collections",
     "Default": "Default",
-    "DeviceOfflineWithName": "{0} has disconnected",
-    "DeviceOnlineWithName": "{0} is connected",
     "External": "External",
     "FailedLoginAttemptWithUserName": "Failed login attempt from {0}",
     "Favorites": "Favorites",
     "Folders": "Folders",
     "Forced": "Forced",
     "Genres": "Genres",
-    "HeaderAlbumArtists": "Album artists",
     "HeaderContinueWatching": "Continue Watching",
-    "HeaderFavoriteAlbums": "Favorite Albums",
-    "HeaderFavoriteArtists": "Favorite Artists",
     "HeaderFavoriteEpisodes": "Favorite Episodes",
     "HeaderFavoriteShows": "Favorite Shows",
-    "HeaderFavoriteSongs": "Favorite Songs",
     "HeaderLiveTV": "Live TV",
     "HeaderNextUp": "Next Up",
-    "HeaderRecordingGroups": "Recording Groups",
     "HearingImpaired": "Hearing Impaired",
     "HomeVideos": "Home Videos",
     "Inherit": "Inherit",
-    "ItemAddedWithName": "{0} was added to the library",
-    "ItemRemovedWithName": "{0} was removed from the library",
     "LabelIpAddressValue": "IP address: {0}",
     "LabelRunningTimeValue": "Running time: {0}",
     "Latest": "Latest",
-    "MessageApplicationUpdated": "Jellyfin Server has been updated",
+    "LyricDownloadFailureFromForItem": "Lyrics failed to download from {0} for {1}",
-    "MessageApplicationUpdatedTo": "Jellyfin Server has been updated to {0}",
-    "MessageNamedServerConfigurationUpdatedWithValue": "Server configuration section {0} has been updated",
-    "MessageServerConfigurationUpdated": "Server configuration has been updated",
     "MixedContent": "Mixed content",
     "Movies": "Movies",
     "Music": "Music",
@@ -64,25 +48,17 @@
     "NotificationOptionUserLockedOut": "User locked out",
     "NotificationOptionVideoPlayback": "Video playback started",
     "NotificationOptionVideoPlaybackStopped": "Video playback stopped",
+    "Original": "Original",
     "Photos": "Photos",
-    "Playlists": "Playlists",
-    "Plugin": "Plugin",
     "PluginInstalledWithName": "{0} was installed",
     "PluginUninstalledWithName": "{0} was uninstalled",
     "PluginUpdatedWithName": "{0} was updated",
-    "ProviderValue": "Provider: {0}",
     "ScheduledTaskFailedWithName": "{0} failed",
-    "ScheduledTaskStartedWithName": "{0} started",
-    "ServerNameNeedsToBeRestarted": "{0} needs to be restarted",
     "Shows": "Shows",
-    "Songs": "Songs",
     "StartupEmbyServerIsLoading": "Jellyfin Server is loading. Please try again shortly.",
     "SubtitleDownloadFailureFromForItem": "Subtitles failed to download from {0} for {1}",
-    "Sync": "Sync",
-    "System": "System",
     "TvShows": "TV Shows",
     "Undefined": "Undefined",
-    "User": "User",
     "UserCreatedWithName": "User {0} has been created",
     "UserDeletedWithName": "User {0} has been deleted",
     "UserDownloadingItemWithValues": "{0} is downloading {1}",
@@ -90,11 +66,8 @@
     "UserOfflineFromDevice": "{0} has disconnected from {1}",
     "UserOnlineFromDevice": "{0} is online from {1}",
     "UserPasswordChangedWithName": "Password has been changed for user {0}",
-    "UserPolicyUpdatedWithName": "User policy has been updated for {0}",
     "UserStartedPlayingItemWithValues": "{0} is playing {1} on {2}",
     "UserStoppedPlayingItemWithValues": "{0} has finished playing {1} on {2}",
-    "ValueHasBeenAddedToLibrary": "{0} has been added to your media library",
-    "ValueSpecialEpisodeName": "Special - {0}",
     "VersionNumber": "Version {0}",
     "TasksMaintenanceCategory": "Maintenance",
     "TasksLibraryCategory": "Library",
@@ -130,8 +103,6 @@
     "TaskOptimizeDatabaseDescription": "Compacts database and truncates free space. Running this task after scanning the library or doing other changes that imply database modifications might improve performance.",
     "TaskKeyframeExtractor": "Keyframe Extractor",
     "TaskKeyframeExtractorDescription": "Extracts keyframes from video files to create more precise HLS playlists. This task may run for a long time.",
-    "TaskCleanCollectionsAndPlaylists": "Clean up collections and playlists",
-    "TaskCleanCollectionsAndPlaylistsDescription": "Removes items from collections and playlists that no longer exist.",
     "TaskExtractMediaSegments": "Media Segment Scan",
     "TaskExtractMediaSegmentsDescription": "Extracts or obtains media segments from MediaSegment enabled plugins.",
     "TaskMoveTrickplayImages": "Migrate Trickplay Image Location",

Emby.Server.Implementations/Localization/Core/eo.json

@@ -7,35 +7,22 @@
     "NameInstallFailed": "{0} instalado fiaskis",
     "Music": "Muziko",
     "Movies": "Filmoj",
-    "ItemRemovedWithName": "{0} forigis el la plurmediteko",
-    "ItemAddedWithName": "{0} aldonis al la plurmediteko",
     "HeaderLiveTV": "TV-etero",
     "HeaderContinueWatching": "Daŭrigi Spektadon",
-    "HeaderAlbumArtists": "Artistoj de albumo",
     "Folders": "Dosierujoj",
-    "DeviceOnlineWithName": "{0} estas konektita",
     "Default": "Defaŭlte",
     "Collections": "Kolektoj",
     "ChapterNameValue": "Ĉapitro {0}",
-    "Channels": "Kanaloj",
     "Books": "Libroj",
     "Artists": "Artistoj",
-    "Application": "Aplikaĵo",
     "AppDeviceValues": "Aplikaĵo: {0}, Aparato: {1}",
-    "Albums": "Albumoj",
     "TasksLibraryCategory": "Plurmediteko",
     "VersionNumber": "Versio {0}",
     "UserDownloadingItemWithValues": "{0} elŝutas {1}",
     "UserCreatedWithName": "Uzanto {0} kreiĝis",
-    "User": "Uzanto",
-    "System": "Sistemo",
-    "Songs": "Kantoj",
-    "ScheduledTaskStartedWithName": "{0} lanĉis",
     "ScheduledTaskFailedWithName": "{0} malsukcesis",
     "PluginUninstalledWithName": "{0} malinstaliĝis",
     "PluginInstalledWithName": "{0} instaliĝis",
-    "Plugin": "Kromprogramo",
-    "Playlists": "Ludlistoj",
     "Photos": "Fotoj",
     "NotificationOptionPluginUninstalled": "Kromprogramo malinstaliĝis",
     "NotificationOptionNewLibraryContent": "Nova enhavo aldoniĝis",
@@ -43,36 +30,28 @@
     "MusicVideos": "Muzikvideoj",
     "LabelIpAddressValue": "IP-adreso: {0}",
     "Genres": "Ĝenroj",
-    "DeviceOfflineWithName": "{0} malkonektis",
-    "HeaderFavoriteArtists": "Favorataj Artistoj",
     "Shows": "Serioj",
     "HeaderFavoriteShows": "Favorataj Serioj",
     "TvShows": "TV-serioj",
     "Favorites": "Favorataj",
     "TaskCleanLogs": "Purigi Ĵurnalan Katalogon",
     "TaskRefreshLibrary": "Skani Plurmeditekon",
-    "ValueSpecialEpisodeName": "Speciala - {0}",
     "TaskOptimizeDatabase": "Optimumigi datenbazon",
     "TaskRefreshChannels": "Refreŝigi Kanalojn",
     "TaskUpdatePlugins": "Ĝisdatigi Kromprogramojn",
     "TaskRefreshPeople": "Refreŝigi Homojn",
     "TasksChannelsCategory": "Interretaj Kanaloj",
-    "ProviderValue": "Provizanto: {0}",
     "NotificationOptionPluginError": "Kromprogramo malsukcesis",
     "MixedContent": "Miksita enhavo",
     "TasksApplicationCategory": "Aplikaĵo",
     "TasksMaintenanceCategory": "Prizorgado",
     "Undefined": "Nedifinita",
-    "Sync": "Sinkronigo",
     "Latest": "Plej novaj",
     "Inherit": "Hereda",
     "HomeVideos": "Hejmaj Videoj",
     "HeaderNextUp": "Sekva Plue",
-    "HeaderFavoriteSongs": "Favorataj Kantoj",
     "HeaderFavoriteEpisodes": "Favorataj Epizodoj",
-    "HeaderFavoriteAlbums": "Favorataj Albumoj",
     "Forced": "Forcita",
-    "ServerNameNeedsToBeRestarted": "{0} devas esti relanĉita",
     "NotificationOptionVideoPlayback": "La videoludado lanĉis",
     "NotificationOptionServerRestartRequired": "Servila relanĉigo bezonata",
     "TaskOptimizeDatabaseDescription": "Kompaktigas datenbazon kaj trunkas liberan lokon. Lanĉi ĉi tiun taskon post la plurmediteka skanado aŭ fari aliajn ŝanĝojn, kiuj implicas datenbazajn modifojn, povus plibonigi rendimenton.",
@@ -85,22 +64,16 @@
     "TaskCleanCacheDescription": "Forigas stapla dosierojn ne plu necesajn de la sistemo.",
     "TaskCleanActivityLogDescription": "Forigas aktivecan ĵurnalaĵojn pli malnovajn ol la agordita aĝo.",
     "TaskCleanTranscodeDescription": "Forigas transkodajn dosierojn aĝajn pli ol unu tagon.",
-    "ValueHasBeenAddedToLibrary": "{0} estis aldonita al via plurmediteko",
     "SubtitleDownloadFailureFromForItem": "Subtekstoj malsukcesis elŝuti de {0} por {1}",
     "StartupEmbyServerIsLoading": "Jellyfin Server ŝarĝas. Provi denove baldaŭ.",
     "TaskRefreshChapterImagesDescription": "Kreas bildetojn por videoj kiuj havas ĉapitrojn.",
     "UserStoppedPlayingItemWithValues": "{0} finis ludi {1} ĉe {2}",
-    "UserPolicyUpdatedWithName": "Uzanta politiko estis ĝisdatigita por {0}",
     "UserPasswordChangedWithName": "Pasvorto estis ŝanĝita por uzanto {0}",
     "UserStartedPlayingItemWithValues": "{0} ludas {1} ĉe {2}",
     "UserLockedOutWithName": "Uzanto {0} estas elŝlosita",
     "UserOnlineFromDevice": "{0} estas enreta de {1}",
     "UserOfflineFromDevice": "{0} malkonektis de {1}",
     "UserDeletedWithName": "Uzanto {0} estis forigita",
-    "MessageServerConfigurationUpdated": "Servila agordaro estis ĝisdatigita",
-    "MessageNamedServerConfigurationUpdatedWithValue": "Servila agorda sekcio {0} estis ĝisdatigita",
-    "MessageApplicationUpdatedTo": "Jellyfin Server estis ĝisdatigita al {0}",
-    "MessageApplicationUpdated": "Jellyfin Server estis ĝisdatigita",
     "TaskRefreshChannelsDescription": "Refreŝigas informon pri interretaj kanaloj.",
     "TaskDownloadMissingSubtitles": "Elŝuti mankantajn subtekstojn",
     "TaskCleanTranscode": "Malplenigi Transkodadan Katalogon",
@@ -116,9 +89,7 @@
     "NotificationOptionApplicationUpdateInstalled": "Aplikaĵa ĝisdatigo instalita",
     "NotificationOptionApplicationUpdateAvailable": "Ĝisdatigo de aplikaĵo havebla",
     "LabelRunningTimeValue": "Ludada tempo: {0}",
-    "HeaderRecordingGroups": "Rikordadaj Grupoj",
     "FailedLoginAttemptWithUserName": "Malsukcesa ensaluta provo de {0}",
-    "CameraImageUploadedFrom": "Nova kamera bildo estis alŝutita de {0}",
     "AuthenticationSucceededWithUserName": "{0} sukcese aŭtentikigis",
     "TaskKeyframeExtractorDescription": "Eltiras ĉefkadrojn el videodosieroj por krei pli precizajn HLS-ludlistojn. Ĉi tiu tasko povas funkcii dum longa tempo.",
     "TaskKeyframeExtractor": "Eltiri Ĉefkadrojn",

Emby.Server.Implementations/Localization/Core/es-AR.json

@@ -1,41 +1,24 @@
 {
-    "Albums": "Álbumes",
     "AppDeviceValues": "Aplicación: {0}, Dispositivo: {1}",
-    "Application": "Aplicación",
     "Artists": "Artistas",
     "AuthenticationSucceededWithUserName": "{0} autenticado correctamente",
     "Books": "Libros",
-    "CameraImageUploadedFrom": "Se ha subido una nueva imagen de cámara desde {0}",
-    "Channels": "Canales",
     "ChapterNameValue": "Capítulo {0}",
     "Collections": "Colecciones",
-    "DeviceOfflineWithName": "{0} se ha desconectado",
-    "DeviceOnlineWithName": "{0} está conectado",
     "FailedLoginAttemptWithUserName": "Error al intentar iniciar sesión de {0}",
     "Favorites": "Favoritos",
     "Folders": "Carpetas",
     "Genres": "Géneros",
-    "HeaderAlbumArtists": "Artistas del álbum",
     "HeaderContinueWatching": "Seguir viendo",
-    "HeaderFavoriteAlbums": "Álbumes favoritos",
-    "HeaderFavoriteArtists": "Artistas favoritos",
     "HeaderFavoriteEpisodes": "Capítulos favoritos",
-    "HeaderFavoriteShows": "Programas favoritos",
+    "HeaderFavoriteShows": "Series favoritas",
-    "HeaderFavoriteSongs": "Canciones favoritas",
     "HeaderLiveTV": "TV en vivo",
     "HeaderNextUp": "Siguiente",
-    "HeaderRecordingGroups": "Grupos de grabación",
     "HomeVideos": "Videos caseros",
     "Inherit": "Heredar",
-    "ItemAddedWithName": "{0} se ha añadido a la biblioteca",
-    "ItemRemovedWithName": "{0} ha sido eliminado de la biblioteca",
     "LabelIpAddressValue": "Dirección IP: {0}",
     "LabelRunningTimeValue": "Tiempo de funcionamiento: {0}",
     "Latest": "Últimos",
-    "MessageApplicationUpdated": "El servidor Jellyfin fue actualizado",
-    "MessageApplicationUpdatedTo": "Se ha actualizado el servidor Jellyfin a la versión {0}",
-    "MessageNamedServerConfigurationUpdatedWithValue": "Se ha actualizado la sección {0} de la configuración del servidor",
-    "MessageServerConfigurationUpdated": "Se ha actualizado la configuración del servidor",
     "MixedContent": "Contenido mezclado",
     "Movies": "Películas",
     "Music": "Música",
@@ -61,24 +44,14 @@
     "NotificationOptionVideoPlayback": "Se inició la reproducción de video",
     "NotificationOptionVideoPlaybackStopped": "Reproducción de video detenida",
     "Photos": "Fotos",
-    "Playlists": "Listas de reproducción",
-    "Plugin": "Complemento",
     "PluginInstalledWithName": "{0} fue instalado",
     "PluginUninstalledWithName": "{0} fue desinstalado",
     "PluginUpdatedWithName": "{0} fue actualizado",
-    "ProviderValue": "Proveedor: {0}",
     "ScheduledTaskFailedWithName": "{0} falló",
-    "ScheduledTaskStartedWithName": "{0} iniciado",
+    "Shows": "Series",
-    "ServerNameNeedsToBeRestarted": "{0} necesita ser reiniciado",
-    "Shows": "Programas",
-    "Songs": "Canciones",
     "StartupEmbyServerIsLoading": "El servidor Jellyfin se está cargando. Vuelve a intentarlo en breve.",
-    "SubtitleDownloadFailureForItem": "Subtitles failed to download for {0}",
     "SubtitleDownloadFailureFromForItem": "Falló la descarga de subtitulos desde {0} para {1}",
-    "Sync": "Sincronizar",
-    "System": "Sistema",
     "TvShows": "Series de TV",
-    "User": "Usuario",
     "UserCreatedWithName": "El usuario {0} ha sido creado",
     "UserDeletedWithName": "El usuario {0} ha sido borrado",
     "UserDownloadingItemWithValues": "{0} está descargando {1}",
@@ -86,11 +59,8 @@
     "UserOfflineFromDevice": "{0} se ha desconectado de {1}",
     "UserOnlineFromDevice": "{0} está en línea desde {1}",
     "UserPasswordChangedWithName": "Se ha cambiado la contraseña para el usuario {0}",
-    "UserPolicyUpdatedWithName": "Las política de usuario ha sido actualizada para {0}",
     "UserStartedPlayingItemWithValues": "{0} está reproduciendo {1} en {2}",
     "UserStoppedPlayingItemWithValues": "{0} ha terminado de reproducir {1} en {2}",
-    "ValueHasBeenAddedToLibrary": "{0} ha sido añadido a tu biblioteca multimedia",
-    "ValueSpecialEpisodeName": "Especial - {0}",
     "VersionNumber": "Versión {0}",
     "TaskDownloadMissingSubtitlesDescription": "Busca en internet los subtítulos que falten basándose en la configuración de los metadatos.",
     "TaskDownloadMissingSubtitles": "Descargar subtítulos faltantes",
@@ -129,8 +99,6 @@
     "TaskRefreshTrickplayImagesDescription": "Crea vistas previas de reproducción engañosa para videos en bibliotecas habilitadas.",
     "TaskAudioNormalization": "Normalización de audio",
     "TaskAudioNormalizationDescription": "Escanea archivos en busca de datos de normalización de audio.",
-    "TaskCleanCollectionsAndPlaylists": "Limpiar colecciones y listas de reproducción",
-    "TaskCleanCollectionsAndPlaylistsDescription": "Elimina elementos de colecciones y listas de reproducción que ya no existen.",
     "TaskDownloadMissingLyrics": "Descargar letra faltante",
     "TaskDownloadMissingLyricsDescription": "Descarga letras de canciones",
     "TaskExtractMediaSegments": "Escanear Segmentos de Media",

Emby.Server.Implementations/Localization/Core/es-MX.json

@@ -1,41 +1,24 @@
 {
-    "Albums": "Álbumes",
     "AppDeviceValues": "App: {0}, Dispositivo: {1}",
-    "Application": "Aplicación",
     "Artists": "Artistas",
     "AuthenticationSucceededWithUserName": "{0} autenticado con éxito",
     "Books": "Libros",
-    "CameraImageUploadedFrom": "Una nueva imagen de cámara ha sido subida desde {0}",
-    "Channels": "Canales",
     "ChapterNameValue": "Capítulo {0}",
     "Collections": "Colecciones",
-    "DeviceOfflineWithName": "{0} se ha desconectado",
-    "DeviceOnlineWithName": "{0} está conectado",
     "FailedLoginAttemptWithUserName": "Intento fallido de inicio de sesión de {0}",
     "Favorites": "Favoritos",
     "Folders": "Carpetas",
     "Genres": "Géneros",
-    "HeaderAlbumArtists": "Artistas del Álbum",
     "HeaderContinueWatching": "Continuar viendo",
-    "HeaderFavoriteAlbums": "Álbumes favoritos",
-    "HeaderFavoriteArtists": "Artistas favoritos",
     "HeaderFavoriteEpisodes": "Episodios favoritos",
     "HeaderFavoriteShows": "Programas favoritos",
-    "HeaderFavoriteSongs": "Canciones favoritas",
     "HeaderLiveTV": "TV en vivo",
     "HeaderNextUp": "A continuación",
-    "HeaderRecordingGroups": "Grupos de grabación",
     "HomeVideos": "Videos Caseros",
     "Inherit": "Heredar",
-    "ItemAddedWithName": "{0} fue agregado a la biblioteca",
-    "ItemRemovedWithName": "{0} fue removido de la biblioteca",
     "LabelIpAddressValue": "Dirección IP: {0}",
-    "LabelRunningTimeValue": "Tiempo de reproducción: {0}",
+    "LabelRunningTimeValue": "Tiempo corriendo: {0}",
     "Latest": "Recientes",
-    "MessageApplicationUpdated": "El servidor Jellyfin ha sido actualizado",
-    "MessageApplicationUpdatedTo": "El servidor Jellyfin ha sido actualizado a {0}",
-    "MessageNamedServerConfigurationUpdatedWithValue": "Se ha actualizado la sección {0} de la configuración del servidor",
-    "MessageServerConfigurationUpdated": "Se ha actualizado la configuración del servidor",
     "MixedContent": "Contenido mezclado",
     "Movies": "Películas",
     "Music": "Música",
@@ -61,24 +44,14 @@
     "NotificationOptionVideoPlayback": "Reproducción de video iniciada",
     "NotificationOptionVideoPlaybackStopped": "Reproducción de video detenida",
     "Photos": "Fotos",
-    "Playlists": "Listas de reproducción",
-    "Plugin": "Complemento",
     "PluginInstalledWithName": "{0} fue instalado",
     "PluginUninstalledWithName": "{0} fue desinstalado",
     "PluginUpdatedWithName": "{0} fue actualizado",
-    "ProviderValue": "Proveedor: {0}",
     "ScheduledTaskFailedWithName": "{0} falló",
-    "ScheduledTaskStartedWithName": "{0} iniciado",
-    "ServerNameNeedsToBeRestarted": "{0} necesita ser reiniciado",
     "Shows": "Programas",
-    "Songs": "Canciones",
     "StartupEmbyServerIsLoading": "El servidor Jellyfin está cargando. Por favor, intente de nuevo pronto.",
-    "SubtitleDownloadFailureForItem": "Falló la descarga de subtítulos para {0}",
     "SubtitleDownloadFailureFromForItem": "Falló la descarga de subtítulos desde {0} para {1}",
-    "Sync": "Sincronizar",
-    "System": "Sistema",
     "TvShows": "Programas de TV",
-    "User": "Usuario",
     "UserCreatedWithName": "El usuario {0} ha sido creado",
     "UserDeletedWithName": "El usuario {0} ha sido eliminado",
     "UserDownloadingItemWithValues": "{0} está descargando {1}",
@@ -86,11 +59,8 @@
     "UserOfflineFromDevice": "{0} se ha desconectado desde {1}",
     "UserOnlineFromDevice": "{0} está en línea desde {1}",
     "UserPasswordChangedWithName": "Se ha cambiado la contraseña para el usuario {0}",
-    "UserPolicyUpdatedWithName": "La política de usuario ha sido actualizada para {0}",
     "UserStartedPlayingItemWithValues": "{0} está reproduciendo {1} en {2}",
     "UserStoppedPlayingItemWithValues": "{0} ha terminado de reproducir {1} en {2}",
-    "ValueHasBeenAddedToLibrary": "{0} se ha añadido a tu biblioteca de medios",
-    "ValueSpecialEpisodeName": "Especial - {0}",
     "VersionNumber": "Versión {0}",
     "TaskDownloadMissingSubtitlesDescription": "Busca subtítulos faltantes en Internet basándose en la configuración de metadatos.",
     "TaskDownloadMissingSubtitles": "Descargar subtítulos faltantes",
@@ -129,8 +99,6 @@
     "TaskRefreshTrickplayImages": "Generar imágenes de la barra de reproducción",
     "TaskAudioNormalization": "Normalización de audio",
     "TaskAudioNormalizationDescription": "Analiza los archivos para normalizar el audio.",
-    "TaskCleanCollectionsAndPlaylists": "Limpieza de colecciones y listas de reproducción",
-    "TaskCleanCollectionsAndPlaylistsDescription": "Quita elementos que ya no existen de colecciones y listas de reproducción.",
     "TaskDownloadMissingLyrics": "descargar letras que faltan",
     "TaskDownloadMissingLyricsDescription": "Descargar letras de canciones",
     "TaskExtractMediaSegments": "Escaneo de segmentos de medios",

Emby.Server.Implementations/Localization/Core/es.json

@@ -1,41 +1,24 @@
 {
-    "Albums": "Álbumes",
     "AppDeviceValues": "Aplicación: {0}, Dispositivo: {1}",
-    "Application": "Aplicación",
     "Artists": "Artistas",
     "AuthenticationSucceededWithUserName": "{0} autenticado correctamente",
     "Books": "Libros",
-    "CameraImageUploadedFrom": "Se ha subido una nueva imagen por cámara desde {0}",
-    "Channels": "Canales",
     "ChapterNameValue": "Capítulo {0}",
     "Collections": "Colecciones",
-    "DeviceOfflineWithName": "{0} se ha desconectado",
-    "DeviceOnlineWithName": "{0} está conectado",
     "FailedLoginAttemptWithUserName": "Intento fallido de inicio de sesión de {0}",
     "Favorites": "Favoritos",
     "Folders": "Carpetas",
     "Genres": "Géneros",
-    "HeaderAlbumArtists": "Artistas del álbum",
     "HeaderContinueWatching": "Seguir viendo",
-    "HeaderFavoriteAlbums": "Álbumes favoritos",
-    "HeaderFavoriteArtists": "Artistas favoritos",
     "HeaderFavoriteEpisodes": "Episodios favoritos",
     "HeaderFavoriteShows": "Series favoritas",
-    "HeaderFavoriteSongs": "Canciones favoritas",
     "HeaderLiveTV": "Televisión en directo",
     "HeaderNextUp": "Siguiente",
-    "HeaderRecordingGroups": "Grupos de grabación",
     "HomeVideos": "Vídeos caseros",
     "Inherit": "Heredar",
-    "ItemAddedWithName": "{0} se ha añadido a la biblioteca",
-    "ItemRemovedWithName": "{0} ha sido eliminado de la biblioteca",
     "LabelIpAddressValue": "Dirección IP: {0}",
     "LabelRunningTimeValue": "Duración: {0}",
     "Latest": "Últimas",
-    "MessageApplicationUpdated": "Se ha actualizado el servidor Jellyfin",
-    "MessageApplicationUpdatedTo": "Se ha actualizado el servidor Jellyfin a la versión {0}",
-    "MessageNamedServerConfigurationUpdatedWithValue": "La sección {0} de configuración del servidor ha sido actualizada",
-    "MessageServerConfigurationUpdated": "Se ha actualizado la configuración del servidor",
     "MixedContent": "Contenido mixto",
     "Movies": "Películas",
     "Music": "Música",
@@ -61,24 +44,14 @@
     "NotificationOptionVideoPlayback": "Se inició la reproducción de vídeo",
     "NotificationOptionVideoPlaybackStopped": "Reproducción de vídeo detenida",
     "Photos": "Fotos",
-    "Playlists": "Listas de reproducción",
-    "Plugin": "Plugin",
     "PluginInstalledWithName": "{0} se ha instalado",
     "PluginUninstalledWithName": "{0} se ha desinstalado",
     "PluginUpdatedWithName": "{0} se actualizó",
-    "ProviderValue": "Proveedor: {0}",
     "ScheduledTaskFailedWithName": "{0} falló",
-    "ScheduledTaskStartedWithName": "{0} iniciada",
-    "ServerNameNeedsToBeRestarted": "{0} necesita ser reiniciado",
     "Shows": "Series",
-    "Songs": "Canciones",
     "StartupEmbyServerIsLoading": "Jellyfin Server se está cargando. Vuelve a intentarlo en breve.",
-    "SubtitleDownloadFailureForItem": "Error al descargar subtítulos para {0}",
     "SubtitleDownloadFailureFromForItem": "Fallo en la descarga de subtítulos desde {0} para {1}",
-    "Sync": "Sincronizar",
-    "System": "Sistema",
     "TvShows": "Series",
-    "User": "Usuario",
     "UserCreatedWithName": "El usuario {0} ha sido creado",
     "UserDeletedWithName": "El usuario {0} ha sido borrado",
     "UserDownloadingItemWithValues": "{0} está descargando {1}",
@@ -86,11 +59,8 @@
     "UserOfflineFromDevice": "{0} se ha desconectado desde {1}",
     "UserOnlineFromDevice": "{0} está en línea desde {1}",
     "UserPasswordChangedWithName": "Se ha cambiado la contraseña para el usuario {0}",
-    "UserPolicyUpdatedWithName": "Actualizada política de usuario para {0}",
     "UserStartedPlayingItemWithValues": "{0} está reproduciendo {1} en {2}",
     "UserStoppedPlayingItemWithValues": "{0} ha terminado de reproducir {1} en {2}",
-    "ValueHasBeenAddedToLibrary": "{0} ha sido añadido a tu biblioteca multimedia",
-    "ValueSpecialEpisodeName": "Especial - {0}",
     "VersionNumber": "Versión {0}",
     "TasksMaintenanceCategory": "Mantenimiento",
     "TasksLibraryCategory": "Biblioteca",
@@ -127,8 +97,6 @@
     "HearingImpaired": "Discapacidad Auditiva",
     "TaskRefreshTrickplayImages": "Generar miniaturas de línea de tiempo",
     "TaskRefreshTrickplayImagesDescription": "Crear miniaturas de tiempo para videos en las librerías habilitadas.",
-    "TaskCleanCollectionsAndPlaylists": "Limpiar colecciones y listas de reproducción",
-    "TaskCleanCollectionsAndPlaylistsDescription": "Elimina elementos de colecciones y listas de reproducción que ya no existen.",
     "TaskAudioNormalization": "Normalización de audio",
     "TaskAudioNormalizationDescription": "Escanear archivos para obtener datos de normalización.",
     "TaskDownloadMissingLyricsDescription": "Descargar letras para las canciones",
@@ -138,5 +106,6 @@
     "TaskExtractMediaSegmentsDescription": "Extrae u obtiene segmentos de medios de plugins habilitados para MediaSegment.",
     "TaskMoveTrickplayImages": "Migrar la ubicación de la imagen de Trickplay",
     "CleanupUserDataTask": "Tarea de limpieza de datos del usuario",
-    "CleanupUserDataTaskDescription": "Limpia todos los datos del usuario (estado de visualización, favoritos, etc.) de los medios que ya no están disponibles desde hace al menos 90 días."
+    "CleanupUserDataTaskDescription": "Limpia todos los datos del usuario (estado de visualización, favoritos, etc.) de los medios que ya no están disponibles desde hace al menos 90 días.",
+    "Original": "Original"
 }

Emby.Server.Implementations/Localization/Core/es_419.json

@@ -1,29 +1,19 @@
 {
     "LabelRunningTimeValue": "Tiempo en ejecución: {0}",
-    "ValueSpecialEpisodeName": "Especial - {0}",
-    "Sync": "Sincronizar",
-    "Songs": "Canciones",
     "Shows": "Programas",
-    "Playlists": "Listas de reproducción",
     "Photos": "Fotos",
     "Movies": "Películas",
     "HeaderNextUp": "A continuación",
     "HeaderLiveTV": "TV en vivo",
-    "HeaderFavoriteSongs": "Canciones favoritas",
-    "HeaderFavoriteArtists": "Artistas favoritos",
-    "HeaderFavoriteAlbums": "Álbumes favoritos",
     "HeaderFavoriteEpisodes": "Episodios favoritos",
     "HeaderFavoriteShows": "Programas favoritos",
     "HeaderContinueWatching": "Continuar viendo",
-    "HeaderAlbumArtists": "Artistas de álbum",
     "Genres": "Géneros",
     "Folders": "Carpetas",
     "Favorites": "Favoritos",
     "Collections": "Colecciones",
-    "Channels": "Canales",
     "Books": "Libros",
     "Artists": "Artistas",
-    "Albums": "Álbumes",
     "TaskDownloadMissingSubtitlesDescription": "Busca subtítulos faltantes en Internet basándose en la configuración de metadatos.",
     "TaskDownloadMissingSubtitles": "Descargar subtítulos faltantes",
     "TaskRefreshChannelsDescription": "Actualiza la información de canales de Internet.",
@@ -47,10 +37,8 @@
     "TasksLibraryCategory": "Biblioteca",
     "TasksMaintenanceCategory": "Mantenimiento",
     "VersionNumber": "Versión {0}",
-    "ValueHasBeenAddedToLibrary": "{0} se ha añadido a tu biblioteca de medios",
     "UserStoppedPlayingItemWithValues": "{0} ha terminado de reproducir {1} en {2}",
     "UserStartedPlayingItemWithValues": "{0} está reproduciendo {1} en {2}",
-    "UserPolicyUpdatedWithName": "La política de usuario ha sido actualizada para {0}",
     "UserPasswordChangedWithName": "Se ha cambiado la contraseña para el usuario {0}",
     "UserOnlineFromDevice": "{0} está en línea desde {1}",
     "UserOfflineFromDevice": "{0} se ha desconectado desde {1}",
@@ -58,19 +46,13 @@
     "UserDownloadingItemWithValues": "{0} está descargando {1}",
     "UserDeletedWithName": "El usuario {0} ha sido eliminado",
     "UserCreatedWithName": "El usuario {0} ha sido creado",
-    "User": "Usuario",
     "TvShows": "Programas de TV",
-    "System": "Sistema",
     "SubtitleDownloadFailureFromForItem": "Falló la descarga de subtítulos desde {0} para {1}",
     "StartupEmbyServerIsLoading": "El servidor Jellyfin está cargando. Por favor, intente de nuevo pronto.",
-    "ServerNameNeedsToBeRestarted": "{0} debe ser reiniciado",
-    "ScheduledTaskStartedWithName": "{0} iniciado",
     "ScheduledTaskFailedWithName": "{0} falló",
-    "ProviderValue": "Proveedor: {0}",
     "PluginUpdatedWithName": "{0} fue actualizado",
     "PluginUninstalledWithName": "{0} fue desinstalado",
     "PluginInstalledWithName": "{0} fue instalado",
-    "Plugin": "Complemento",
     "NotificationOptionVideoPlaybackStopped": "Reproducción de video detenida",
     "NotificationOptionVideoPlayback": "Reproducción de video iniciada",
     "NotificationOptionUserLockedOut": "Usuario bloqueado",
@@ -94,24 +76,13 @@
     "MusicVideos": "Videos musicales",
     "Music": "Música",
     "MixedContent": "Contenido mezclado",
-    "MessageServerConfigurationUpdated": "Se ha actualizado la configuración del servidor",
-    "MessageNamedServerConfigurationUpdatedWithValue": "Se ha actualizado la sección {0} de la configuración del servidor",
-    "MessageApplicationUpdatedTo": "El servidor Jellyfin ha sido actualizado a {0}",
-    "MessageApplicationUpdated": "El servidor Jellyfin ha sido actualizado",
     "Latest": "Recientes",
     "LabelIpAddressValue": "Dirección IP: {0}",
-    "ItemRemovedWithName": "{0} fue removido de la biblioteca",
-    "ItemAddedWithName": "{0} fue agregado a la biblioteca",
     "Inherit": "Heredar",
     "HomeVideos": "Videos caseros",
-    "HeaderRecordingGroups": "Grupos de grabación",
     "FailedLoginAttemptWithUserName": "Intento de inicio de sesión fallido desde {0}",
-    "DeviceOnlineWithName": "{0} está conectado",
-    "DeviceOfflineWithName": "{0} se ha desconectado",
     "ChapterNameValue": "Capítulo {0}",
-    "CameraImageUploadedFrom": "Una nueva imagen de cámara ha sido subida desde {0}",
     "AuthenticationSucceededWithUserName": "{0} autenticado con éxito",
-    "Application": "Aplicación",
     "AppDeviceValues": "Aplicación: {0}, Dispositivo: {1}",
     "TaskCleanActivityLogDescription": "Elimina las entradas del registro de actividad anteriores al periodo configurado.",
     "TaskCleanActivityLog": "Limpiar registro de actividades",
@@ -127,9 +98,7 @@
     "TaskRefreshTrickplayImagesDescription": "Crea previsualizaciones para la barra de reproducción en las bibliotecas habilitadas.",
     "TaskRefreshTrickplayImages": "Generar imágenes de la barra de reproducción",
     "TaskAudioNormalization": "Normalización de audio",
-    "TaskCleanCollectionsAndPlaylistsDescription": "Quita elementos que ya no existen de colecciones y listas de reproducción.",
     "TaskAudioNormalizationDescription": "Analiza los archivos para normalizar el audio.",
-    "TaskCleanCollectionsAndPlaylists": "Limpieza de colecciones y listas de reproducción",
     "TaskDownloadMissingLyrics": "Descargar letra faltante",
     "TaskDownloadMissingLyricsDescription": "Descarga letras de canciones",
     "TaskExtractMediaSegmentsDescription": "Extrae u obtiene segmentos de medios de complementos habilitados para MediaSegment.",